<html><head><meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"><title>Hierarchical Data Structures and Related Concepts for the C++ Standard Library</title><style type="text/css">

/********************************/
/* start of styles in block.xsl */

.formalpara-title {
  font-weight: bold;
}

div.blockquote-title {
  font-weight: bold;
  margin-top: 1em;
  margin-bottom: 1em;
}

span.msgmain-title {
  font-weight: bold;
}

span.msgsub-title {
  font-weight: bold;
}

span.msgrel-title {
  font-weight: bold;
}

div.msglevel, div.msgorig, div.msgaud {
  margin-top: 1em;
  margin-bottom: 1em;
}

span.msglevel-title, span.msgorig-title, span.msgaud-title {
  font-weight: bold;
}

div.msgexplan {
  margin-top: 1em;
  margin-bottom: 1em;
}

span.msgexplan-title {
  font-weight: bold;
}

/* end of styles in block.xsl */
/********************************/

/********************************/
/* start of styles in autotoc.xsl */


/* end of styles in autotoc.xsl */
/********************************/

/********************************/
/* start of styles in formal.xsl */

div.figure-title {
  font-weight: bold;
}

div.example-title {
  font-weight: bold;
}

div.equation-title {
  font-weight: bold;
}

div.table-title {
  font-weight: bold;
}

div.sidebar-title {
  font-weight: bold;
}


/* end of styles in formal.xsl */
/********************************/

/********************************/
/* start of styles in verbatim.xsl */

div.programlisting {
  white-space: pre;
  font-family: monospace;
}

div.screen {
  white-space: pre;
  font-family: monospace;
}

div.synopsis {
  white-space: pre;
  font-family: monospace;
}

/* end of styles in verbatim.xsl */
/********************************/

/* footnote rule */
hr.footnote-hr {
  width: 100;
}

</style><style type="text/css">
/*=============================================================================
    Copyright (c) 2004 Joel de Guzman
    Copyright (c) 2011-2012 Rene Rivera

    Use, modification and distribution is subject to 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)
=============================================================================*/

/*=============================================================================
    Body defaults
=============================================================================*/
body {
  margin: 1em;
  font-family: sans-serif;
}

/*=============================================================================
    Paragraphs
=============================================================================*/
p {
  text-align: left;
  /* font-size: 10pt; */
  line-height: 1.15;
}

/*=============================================================================
    Program listings
=============================================================================*/

/* Code on paragraphs */
p tt.computeroutput {
  font-size: 9pt;
}

pre.synopsis {
  font-size: 90%;
  margin: 1pc 4% 0pc 4%;
  padding: 0.5pc 0.5pc 0.5pc 0.5pc;
}

.programlisting,.screen {
  font-size: 9pt;
  display: block;
  margin: 1pc 4% 0pc 4%;
  padding: 0.5pc 0.5pc 0.5pc 0.5pc;
}

/* Program listings in tables don't get borders */
td .programlisting,td .screen {
  margin: 0pc 0pc 0pc 0pc;
  padding: 0pc 0pc 0pc 0pc;
}

tt, code, kbd, samp {
  font-size: 115%;
}

/*=============================================================================
    Headings
=============================================================================*/
h1,h2,h3,h4,h5,h6 {
  text-align: left;
  margin: 1em 0em 0.5em 0em;
  font-weight: bold;
}

h1 {
  font: 140%
}

h2 {
  font: bold 140%
}

h3 {
  font: bold 130%
}

h4 {
  font: bold 120%
}

h5 {
  font: italic 110%
}

h6 {
  font: italic 100%
}

/* Top page titles */
title,
.toc-title,
h1.title,
h2.title,
h3.title,
h4.title,
h5.title,
h6.title,
.refentrytitle {
  font-weight: bold;
  margin-bottom: 1pc;
}

h1.title {
  font-size: 140%
}

.toc-title,
h2.title {
  font-size: 140%
}

h3.title {
  font-size: 130%
}

h4.title {
  font-size: 120%
}

h5.title {
  font-size: 110%
}

h6.title {
  font-size: 100%
}

.section h1 {
  margin: 0em 0em 0.5em 0em;
  font-size: 140%;
}

.section h2 {
  font-size: 140%
}

.section h3 {
  font-size: 130%
}

.section h4 {
  font-size: 120%
}

.section h5 {
  font-size: 110%
}

.section h6 {
  font-size: 100%
}

/* Code on titles */
h1 tt.computeroutput {
  font-size: 140%
}

h2 tt.computeroutput {
  font-size: 140%
}

h3 tt.computeroutput {
  font-size: 130%
}

h4 tt.computeroutput {
  font-size: 120%
}

h5 tt.computeroutput {
  font-size: 110%
}

h6 tt.computeroutput {
  font-size: 100%
}

/*=============================================================================
    Author
=============================================================================*/
h3.author {
  font-size: 100%
}

/*=============================================================================
    Lists
=============================================================================*/
li {
  /* font-size: 10pt; */
  line-height: 1.3;
}

/* Unordered lists */
ul {
  text-align: left;
}

/* Ordered lists */
ol {
  text-align: left;
}

/*=============================================================================
    Links
=============================================================================*/
a {
  text-decoration: none; /* no underline */
}

a:hover {
  text-decoration: underline;
}

/*=============================================================================
    Spirit style navigation
=============================================================================*/
.spirit-nav {
  text-align: right;
}

.spirit-nav a {
  color: white;
  padding-left: 0.5em;
}

.spirit-nav img {
  border-width: 0px;
}

/*=============================================================================
    Table of contents
=============================================================================*/
div.toc {
  /*
  margin: 1pc 4% 0pc 4%;
  padding: 0.1pc 1pc 0.1pc 1pc;
  font-size: 80%;
  line-height: 1.15;
  */
}

.boost-toc {
  float: right;
  padding: 0.5pc;
}

dl.toc dl {
  margin-top: 0em;
  margin-bottom: 0em;
}

/*=============================================================================
    Tables
=============================================================================*/
.table-title,div.table p.title {
  margin-left: 4%;
  padding-right: 0.5em;
  padding-left: 0.5em;
}

.informaltable table,.table table {
  width: 92%;
  margin-left: 4%;
  margin-right: 4%;
}

div.informaltable table,div.table table {
  padding: 4px;
}

/* Table Cells */
div.informaltable table tr td,div.table table tr td {
  padding: 0.5em;
  text-align: left;
  /* font-size: 9pt; */
}

div.informaltable table tr th,div.table table tr th {
  padding: 0.5em 0.5em 0.5em 0.5em;
  border: 1pt solid white;
  font-size: 80%;
}

/*=============================================================================
    Blurbs
=============================================================================*/
div.note,div.tip,div.important,div.caution,div.warning,p.blurb {
  /* font-size: 9pt; */ /* A little bit smaller than the main text */
  line-height: 1.2;
  display: block;
  margin: 1pc 4% 0pc 4%;
  padding: 0.5pc 0.5pc 0.5pc 0.5pc;
}

p.blurb img {
  padding: 1pt;
}

/*=============================================================================
    Variable Lists
=============================================================================*/

/* Make the terms in definition lists bold */
div.variablelist dl dt,span.term {
  font-weight: bold;
  /* font-size: 10pt; */
}

div.variablelist table tbody tr td {
  text-align: left;
  vertical-align: top;
  padding: 0em 2em 0em 0em;
  /* font-size: 10pt; */
  margin: 0em 0em 0.5em 0em;
  line-height: 1;
}

div.variablelist dl dt {
  margin-bottom: 0.2em;
}

div.variablelist dl dd {
  margin: 0em 0em 0.5em 2em;
  /* font-size: 10pt; */
}

div.variablelist table tbody tr td p,div.variablelist dl dd p {
  margin: 0em 0em 0.5em 0em;
  line-height: 1;
}

/*=============================================================================
    Misc
=============================================================================*/

/* Title of books and articles in bibliographies */
span.title {
  font-style: italic;
}

span.underline {
  text-decoration: underline;
}

span.strikethrough {
  text-decoration: line-through;
}

/* Copyright, Legal Notice */
div div.legalnotice p {
  text-align: left
}

/*=============================================================================
    Colors
=============================================================================*/
@media screen { /* Links */
  a {
    color: #005a9c;
  }
  a:visited {
    color: #9c5a9c;
  }
  h1 a,h2 a,h3 a,h4 a,h5 a,h6 a,h1 a:hover,h2 a:hover,h3 a:hover,h4 a:hover,h5 a:hover,h6 a:hover,h1 a:visited,h2 a:visited,h3 a:visited,h4 a:visited,h5 a:visited,h6 a:visited
    {
    text-decoration: none; /* no underline */
    color: #000000;
  }

  /* Syntax Highlighting */
  .keyword {
    color: #0000AA;
  }
  .identifier {
    color: #000000;
  }
  .special {
    color: #707070;
  }
  .preprocessor {
    color: #402080;
  }
  .char {
    color: teal;
  }
  .comment {
    color: #800000;
    font-style: italic;
  }
  .string {
    color: teal;
  }
  .number {
    color: teal;
  }
  .white_bkd {
    background-color: #FFFFFF;
  }
  .dk_grey_bkd {
    background-color: #999999;
  }

  /* Copyright, Legal Notice */
  .copyright {
    color: #666666;
    font-size: small;
  }
  div div.legalnotice p {
    color: #666666;
  }

  /* Program listing */
  pre.synopsis {
    border: 1px solid #DCDCDC;
  }
  .programlisting,.screen {
    border: 1px solid #DCDCDC;
  }
  td .programlisting,td .screen {
    border: 0px solid #DCDCDC;
  }

  /* Blurbs */
  div.note,div.tip,div.important,div.caution,div.warning,p.blurb {
    border: 1px solid #DCDCDC;
  }

  /* Table of contents */
  /*
  div.toc {
    border: 1px solid #DCDCDC;
  }
  */

  /* Tables */
  div.informaltable table tr td,div.table table tr td {
    border: 1px solid #DCDCDC;
  }
  div.informaltable table tr th,div.table table tr th {
    background-color: #F0F0F0;
    border: 1px solid #DCDCDC;
  }

  /* Misc */
  span.highlight {
    color: #00A000;
  }
}

@media print { /* Links */
  a {
    color: black;
  }
  a:visited {
    color: black;
  }
  .spirit-nav {
    display: none;
  }

  /* Program listing */
  pre.synopsis {
    border: 1px solid gray;
  }
  .programlisting,.screen {
    border: 1px solid gray;
  }
  td .programlisting,td .screen {
    border: 0px solid #DCDCDC;
  }

  /* Table of contents */
  /*
  div.toc {
    border: 1px solid gray;
  }
  */
  .informaltable table,.table table {
    border: 1px solid gray;
    border-collapse: collapse;
  }

  /* Tables */
  div.informaltable table tr td,div.table table tr td {
    border: 1px solid gray;
  }
  div.informaltable table tr th,div.table table tr th {
    border: 1px solid gray;
  }

  /* Misc */
  span.highlight {
    font-weight: bold;
  }
}

.section {
  clear: both;
}

.article {
  padding-top: 8em;
}

.std_doc_info {
  position: absolute;
  top: 1em;
  font-size: 90%;
  width: 35em;
  right: 1em;
}

.std_doc_info .variablelist dl dt {
  float: left;
}

.std_doc_info .variablelist dl dt .term {
  font-style: italic;
  font-weight: normal;
}

.std_doc_info .variablelist dl dd {
  margin-left: 8em;
}

.std_proposal > .section {
  font-family: Didot, Times, serif;
}

.std_proposal > .section {
  margin: 1em;
  padding: 1em 0em 1em 1.5em;
  border-top: 1px solid #888888;
  border-bottom: 1px solid #888888;
}

.std_proposal .section {
  counter-reset: section-paragraph;
}

.std_proposal .section > p:before,
.std_proposal div.std_paragraph > *:first-child:before,
.std_proposal div.std_requisite > *:first-child:before,
.std_proposal div.std_specification > *:first-child:before
{
  content: counter(section-paragraph);
  counter-increment: section-paragraph;
  display: block;
  width: 4em;
  position: absolute;
  left: 0em;
  text-align: right;
  font-size: 70%;
  padding-top: 0.2em;
}

.std_proposal .std_section_label {
  float: right;
}

.std_proporal .std_paragraph {
}

.std_proporal .std_requisite {
}

.std_proposal .std_definition {
}

.std_proposal .std_specification {
  display: block;
  margin-left: 3em;
}

.std_proposal ol {
  margin: 0em;
  padding: 0em;
}

.std_proposal ol li {
  margin: 0em 0em 1em 0em;
  padding: 0em 0em 0em 0em;
  clear: both;
}

.std_proposal table {
  border: 1px solid;
  margin: 0em auto 0em auto;
  border-spacing: 0em;
  width: inherit;
  padding: 0em !important;
  border-collapse: separate;
}

.std_proposal .table .title,
.std_proposal .table-title {
  font-weight: bold;
  margin: 1em auto 1em auto;
  text-align: center;
  caption-side: top;
}

.std_proposal table th {
  border: none !important;
  border-bottom: 1px solid !important;
  padding: 0.25em 0.5em 0em 0.5em !important;
  background: transparent !important;
}
.std_proposal table th p {
  text-align: center !important;
}

.std_proposal table td {
  border: none !important;
  border-top: 1px solid !important;
  vertical-align: top !important;
  padding: 0.25em 0.5em 0em 0.5em !important;
  background: transparent !important;
}

.std_proposal .docref {
  float: right;
}

.std_proposal .docref dt {
  float: left;
  font-style: italic;
}

.std_proposal .docref dd {
  margin-left: 8em;
}

.std_proposal h1,
.std_proposal h2,
.std_proposal h3,
.std_proposal h4,
.std_proposal h5,
.std_proposal h6 {
  clear: both;
  font-style: normal;
}

.std_proposal .byline {
  text-align: center;
}

.std_proposal .note {
  background: #EEEEEE;
  border: 1px solid #AAAAAA;
  padding: 0.25em;
}
.std_proposal .note .title {
  display: none;
}
.std_proposal .note p {
  margin: 0.25em 0em 0.25em 0em;
}
.std_proposal .note table {
  border: none;
  margin: 0em;
  padding: 0em;
}
.std_proposal .note table td,
.tree_proposal .note table th {
  border: none !important;
}

.std_proposal .add {
  text-decoration: overline;
}

.std_proposal h2 {
  font-size: 150%
}

.std_proposal h3,
.std_proposal h4,
.std_proposal h5,
.std_proposal h6 {
  font-size: 100%;
}

.std_proposal .section-id {
  float: right;
  position: relative;
  top: -1.25em;
}
.std_proposal .programlisting {
  border: none !important;
  margin-left: 0em !important;
  margin-right: 0em !important;
  padding: 0em !important;
}
</style><meta name="generator" content="DocBook XSL Stylesheets V1.78.1"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="article" id="tree"><div class="titlepage"><div><div><h2 class="title">Hierarchical Data Structures and Related Concepts for the C++ Standard Library</h2></div><div><div class="authorgroup"><div class="author"><h3 class="author"><span class="firstname">Bernhard</span> <span class="surname">Reiter</span></h3></div><div class="author"><h3 class="author"><span class="firstname">Ren&#233;</span> <span class="surname">Rivera</span></h3></div></div></div><div><p class="copyright">Copyright &#169; 2006-2009 Bernhard
      Reiter</p></div><div><p class="copyright">Copyright &#169; 2006-2013 Ren&#233; Rivera</p></div><div><div class="legalnotice" id="tree.legal"><p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p></div></div></div><hr></div><div class="toc"><div class="toc-title">Table of Contents</div><dl class="toc"><dt><span class="section"><a href="#tree.preamble">1. Hierarchical Data Structures and Related
    Concepts for the C++ Standard Library</a></span></dt><dd><dl><dt><span class="section"><a href="#tree.preamble.introduction">1.1. Introduction</a></span></dt><dt><span class="section"><a href="#tree.preamble.motivation_and_scope">1.2. Motivation and Scope</a></span></dt><dd><dl><dt><span class="section"><a href="#tree.preamble.motivation_and_scope.why_is_this_important">1.2.1. Why
        is this important?</a></span></dt><dt><span class="section"><a href="#tree.preamble.motivation_and_scope.what_kinds_of_problems_does_it_a">1.2.2. What
        kinds of problems does it address, and what kinds of programmers is it intended
        to support?</a></span></dt><dt><span class="section"><a href="#tree.preamble.motivation_and_scope.is_it_based_on_existing_practice">1.2.3. Is
        it based on existing practice?</a></span></dt><dt><span class="section"><a href="#tree.preamble.motivation_and_scope.is_there_a_reference_implementat">1.2.4. Is
        there a reference implementation?</a></span></dt></dl></dd><dt><span class="section"><a href="#tree.preamble.impact_on_the_standard">1.3. Impact on the Standard</a></span></dt><dd><dl><dt><span class="section"><a href="#tree.preamble.impact_on_the_standard.what_does_it_depend_on_and_what_">1.3.1. What
        does it depend on, and what depends on it?</a></span></dt><dt><span class="section"><a href="#tree.preamble.impact_on_the_standard.is_it_a_pure_extension_or_does_i">1.3.2. Is
        it a pure extension, or does it require changes to standard components?</a></span></dt><dt><span class="section"><a href="#tree.preamble.impact_on_the_standard.can_it_be_implemented_using_toda">1.3.3. Can
        it be implemented using today's compilers, or does it require language features
        that will only be available as part of C++11</a></span></dt></dl></dd><dt><span class="section"><a href="#tree.preamble.important_design_decisions">1.4. Important Design
      Decisions</a></span></dt><dd><dl><dt><span class="section"><a href="#tree.preamble.important_design_decisions.why_did_you_choose_the_specific_">1.4.1. Why
        did you choose the specific design that you did?</a></span></dt><dt><span class="section"><a href="#tree.preamble.important_design_decisions.what_alternatives_did_you_consid">1.4.2. What
        alternatives did you consider, and what are the tradeoffs?</a></span></dt><dt><span class="section"><a href="#tree.preamble.important_design_decisions.what_are_the_consequences_of_you">1.4.3. What
        are the consequences of your choices, for users and implementors?</a></span></dt><dt><span class="section"><a href="#tree.preamble.important_design_decisions.what_decisions_are_left_up_to_im">1.4.4. What
        decisions are left up to implementors?</a></span></dt><dt><span class="section"><a href="#tree.preamble.important_design_decisions.if_there_are_any_similar_librari">1.4.5. If
        there are any similar libraries in use, how do their design decisions compare
        to yours?</a></span></dt></dl></dd><dt><span class="section"><a href="#tree.preamble.future_directions">1.5. Future Directions</a></span></dt></dl></dd><dt><span class="section"><a href="#tree.proposal">2. Proposed Text</a></span></dt><dd><dl><dt><span class="section"><a href="#tree.proposal.containers">23. Container library <span class="std_section_label">[containers]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.proposal.hierarchy">23.7. Hierarchy
  containers <span class="std_section_label">[hierarchy]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.req">23.7.1. Hierarchy containers requirements <span class="std_section_label">[hierarchy.req]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.req.general">23.7.1.1. General hierarchy requirements <span class="std_section_label">[hier.req.general]</span></a></span></dt></dl></dd><dt><span class="section"><a href="#tree.plain">23.7.2. Plain hierarchies <span class="std_section_label">[hierarchy.plain]</span></a></span></dt><dt><span class="section"><a href="#tree.multiway">23.7.3. Multiway hierarchies <span class="std_section_label">[hierarchy.multiway]</span></a></span></dt><dt><span class="section"><a href="#tree.tree">23.7.4. Trees <span class="std_section_label">[hierarchy.tree]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.tree.bintree">23.7.4.1. Class template <code class="literal">binary_tree</code>
      <span class="std_section_label">[hierarchy.bintree]</span></a></span></dt><dt><span class="section"><a href="#tree.tree.narytree">23.7.4.2. Class template <code class="literal">nary_tree</code>
      <span class="std_section_label">[narytree]</span></a></span></dt><dt><span class="section"><a href="#tree.tree.adaptors">23.7.4.3. Hierarchy adaptors <span class="std_section_label">[hierarchy.adaptors]</span></a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="section"><a href="#tree.proposal.iterators">24. Iterators library
  <span class="std_section_label">[iterators]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#iterator.synopsis">24.3. Headers
  <code class="literal">&lt;iterator&gt;</code> synopsis <span class="std_section_label">[iterator.synopsis]</span></a></span></dt><dt><span class="section"><a href="#cursors">24.7. Cursors <span class="std_section_label">[cursors]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.cursor_requirements">24.7.1. Cursor requirements <span class="std_section_label">[cursor.requirements]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.cursor_requirements.descending">24.7.1.1. Descending Cursor
      <span class="std_section_label">[descending.cursors]</span></a></span></dt><dt><span class="section"><a href="#tree.cursor_requirements.descending_forward">24.7.1.2. Descending
      Forward Cursor <span class="std_section_label">[descending.forward.cursors]</span></a></span></dt><dt><span class="section"><a href="#tree.cursor_requirements.descending_bidirectional">24.7.1.3. Descending
      Bidirectional Cursor <span class="std_section_label">[descending.bidirectional.cursors]</span></a></span></dt><dt><span class="section"><a href="#tree.cursor_requirements.descending_random_access">24.7.1.4. Descending
      Random Access Cursor <span class="std_section_label">[descending.random.access.cursors]</span></a></span></dt><dt><span class="section"><a href="#tree.cursor_requirements.ascending">24.7.1.5. Ascending Cursor
      <span class="std_section_label">[ascending.cursors]</span></a></span></dt><dt><span class="section"><a href="#tree.cursor_requirements.ascending_forward">24.7.1.6. Ascending
      Forward Cursor <span class="std_section_label">[ascending.forward.cursors]</span></a></span></dt><dt><span class="section"><a href="#tree.cursor_requirements.ascending_bidirectional">24.7.1.7. Ascending
      Bidirectional Cursor <span class="std_section_label">[ascending.bidirectional.cursors]</span></a></span></dt><dt><span class="section"><a href="#tree.cursor_requirements.ascending_random_access">24.7.1.8. Ascending
      Random Access Cursor <span class="std_section_label">[ascending.random.access.cursors]</span></a></span></dt></dl></dd><dt><span class="section"><a href="#tree.cursor_flavors">24.7.2. Cursor flavors <span class="std_section_label">[cursor.flavors]</span></a></span></dt><dt><span class="section"><a href="#tree.cursor_synopsis">24.7.3. Header <code class="literal">&lt;cursor&gt;</code>
    synopsis <span class="std_section_label">[cursor.synopsis]</span></a></span></dt><dt><span class="section"><a href="#tree.cursor_primitives">24.7.4. Cursor primitives <span class="std_section_label">[cursor.primitives]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.cursor_primitives.cursor_traits">24.7.4.1. Cursor traits
      <span class="std_section_label">[cursor.traits]</span></a></span></dt><dt><span class="section"><a href="#tree.cursor_primitives.cursor_basic">24.7.4.2. Basic cursor <span class="std_section_label">[cursor.basic]</span></a></span></dt><dt><span class="section"><a href="#tree.cursor_primitives.cursor_tags">24.7.4.3. Standard cursor tags
      <span class="std_section_label">[cursor.tags]</span></a></span></dt></dl></dd></dl></dd><dt><span class="section"><a href="#order.iterators">24.8. Linear order traversal iterators <span class="std_section_label">[order.iterators]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.order_iterator">24.8.1. Class template <code class="literal">iterator</code>
    <span class="std_section_label">[order.iterator]</span></a></span></dt><dt><span class="section"><a href="#tree.order_iter_requirements">24.8.2. Linear order <code class="literal">iterator</code>
    requirements <span class="std_section_label">[order.iter.requirements]</span></a></span></dt><dt><span class="section"><a href="#tree.order_iter_ops">24.8.3. <code class="literal">inorder::iterator</code>
    operations <span class="std_section_label">[order.iter.ops]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.order_iter_ops.order_iter_cons">24.8.3.1. <code class="literal">inorder::iterator</code>
      constructor <span class="std_section_label">[order.iter.cons]</span></a></span></dt><dt><span class="section"><a href="#tree.order_iter_ops.order_iter_conv">24.8.3.2. Conversion <span class="std_section_label">[order.iter.conv]</span></a></span></dt><dt><span class="section"><a href="#tree.order_iter_ops.order_iter_op_star">24.8.3.3. <code class="literal">operator*</code>
      <span class="std_section_label">[order.iter.op.star]</span></a></span></dt><dt><span class="section"><a href="#tree.order_iter_ops.order_iter_op_ref">24.8.3.4. <code class="literal">operator-&gt;</code>
      <span class="std_section_label">[order.iter.op.ref]</span></a></span></dt><dt><span class="section"><a href="#tree.order_iter_ops.order_iter_op_inc">24.8.3.5. <code class="literal">operator++</code>
      <span class="std_section_label">[order.iter.op.inc]</span></a></span></dt><dt><span class="section"><a href="#tree.order_iter_ops.order_iter_op_dec">24.8.3.6. <code class="literal">operator--</code>
      <span class="std_section_label">[order.iter.op.dec]</span></a></span></dt><dt><span class="section"><a href="#tree.order_iter_ops.order_iter_op_eq">24.8.3.7. <code class="literal">operator==</code>
      <span class="std_section_label">[order.iter.op.eq]</span></a></span></dt><dt><span class="section"><a href="#tree.order_iter_ops.order_iter_op_ne">24.8.3.8. <code class="literal">operator!=</code>
      <span class="std_section_label">[order.iter.op.ne]</span></a></span></dt></dl></dd></dl></dd></dl></dd><dt><span class="section"><a href="#tree.proposal.algorithms">25. Algorithms
  library <span class="std_section_label">[algorithms]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#alg.hierarchy">25.3. Non-modifying hierarchy algorithms <span class="std_section_label">[alg.hierarchy]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.alg_hier_preorder">25.3.1. Non-modifying hierarchy preorder
    range algorithms <span class="std_section_label">[alg.hier.preorder]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.alg_hier_preorder.alg_hier_pre_begin">25.3.1.1. Preorder begin
      <span class="std_section_label">[alg.hier.pre.begin]</span></a></span></dt><dt><span class="section"><a href="#tree.alg_hier_preorder.alg_hier_pre_end">25.3.1.2. Preorder end
      <span class="std_section_label">[alg.hier.pre.end]</span></a></span></dt></dl></dd><dt><span class="section"><a href="#tree.alg_hier_postorder">25.3.2. Non-modifying hierarchy postorder
    range algorithms <span class="std_section_label">[alg.hier.postorder]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.alg_hier_postorder.alg_hier_post_begin">25.3.2.1. Postorder
      begin <span class="std_section_label">[alg.hier.post.begin]</span></a></span></dt><dt><span class="section"><a href="#tree.alg_hier_postorder.alg_hier_post_end">25.3.2.2. Postorder
      end <span class="std_section_label">[alg.hier.post.end]</span></a></span></dt></dl></dd><dt><span class="section"><a href="#tree.alg_hier_inorder">25.3.3. Non-modifying hierarchy inorder
    range algorithms <span class="std_section_label">[alg.hier.inorder]</span></a></span></dt><dd><dl><dt><span class="section"><a href="#tree.alg_hier_inorder.alg_hier_in_begin">25.3.3.1. Inorder begin
      <span class="std_section_label">[alg.hier.in.begin]</span></a></span></dt><dt><span class="section"><a href="#tree.alg_hier_inorder.alg_hier_in_end">25.3.3.2. Inorder end <span class="std_section_label">[alg.hier.in.end]</span></a></span></dt></dl></dd></dl></dd></dl></dd></dl></dd><dt><span class="section"><a href="#tree.references">3. References</a></span></dt></dl></div><div class="section" id="tree.preamble"><div class="titlepage"><div><div><h2 class="title" style="clear: both">1.&#160;<a class="link" href="#tree.preamble" title="1.&#160;Hierarchical Data Structures and Related Concepts for the C++ Standard Library">Hierarchical Data Structures and Related
    Concepts for the C++ Standard Library</a></h2></div></div></div><p>
      <span class="bold"><strong>Bernhard Reiter and Ren&#233; Rivera</strong></span>
    </p><div class="simplesect std_doc_info" id="idp4528496"><div class="titlepage"></div><div class="variablelist"><div class="variablelist-title"></div><dl class="variablelist"><dt><span class="term">Document No.</span></dt><dd><p>
            WG21/N3700
          </p></dd><dt><span class="term">Supercedes</span></dt><dd><p>
            WG21/N2101=J16/06-0171
          </p></dd><dt><span class="term">Date</span></dt><dd><p>
            2013-06-22
          </p></dd><dt><span class="term">Project</span></dt><dd><p>
            Programming Language C++, Library Working Group
          </p></dd><dt><span class="term">Reply to</span></dt><dd><p>
            Ren&#233; Rivera &lt;<a href="mailto:rrivera@acm.org" target="_top">rrivera@acm.org</a>&gt;
          </p></dd></dl></div></div><div class="section" id="tree.preamble.introduction"><div class="titlepage"><div><div><h3 class="title">1.1.&#160;<a class="link" href="#tree.preamble.introduction" title="1.1.&#160;Introduction">Introduction</a></h3></div></div></div><p>
        This paper proposes the addition of library components covering tree structures
        and related concepts to Programming Languages -- C++. The proposal is based
        on work towards a Boost Tree component library.
      </p><p>
        The library strives to cover many of the relevant aspects within the vast
        field linked to the notion of trees in computer science.
      </p></div><div class="section" id="tree.preamble.motivation_and_scope"><div class="titlepage"><div><div><h3 class="title">1.2.&#160;<a class="link" href="#tree.preamble.motivation_and_scope" title="1.2.&#160;Motivation and Scope">Motivation and Scope</a></h3></div></div></div><div class="section" id="tree.preamble.motivation_and_scope.why_is_this_important"><div class="titlepage"><div><div><h4 class="title">1.2.1.&#160;<a class="link" href="#tree.preamble.motivation_and_scope.why_is_this_important" title="1.2.1.&#160;Why is this important?">Why
        is this important?</a></h4></div></div></div><p>
          This proposal is motivated by the wish to establish methods of dealing
          with hierarchical data structures in a manner that is similar to that of
          the Standard Template Library (STL) for linear ones. That is, it seeks
          to provide clear, straight-forward, versatile and comprehensive concepts,
          data structures and algorithms for trees and related structures that allow
          efficient implementation while not exposing implementation details.
        </p><p>
          In particular, this proposal strives to unite types of hierarchical data
          structures that have historically been treated separately, although there
          is arguably good reason to view their role for algorithms as different
          aspects of common underlying concepts. Formally, this proposal's desired
          scope is covering all <span class="emphasis"><em>rooted ordered connected acyclic graphs</em></span>.
        </p></div><div class="section" id="tree.preamble.motivation_and_scope.what_kinds_of_problems_does_it_a"><div class="titlepage"><div><div><h4 class="title">1.2.2.&#160;<a class="link" href="#tree.preamble.motivation_and_scope.what_kinds_of_problems_does_it_a" title="1.2.2.&#160;What kinds of problems does it address, and what kinds of programmers is it intended to support?">What
        kinds of problems does it address, and what kinds of programmers is it intended
        to support?</a></h4></div></div></div><p>
          Existing tree implementations as listed in the References section as well
          as the number of posts on C++ related newsgroups give an evidence of very
          general, high interest in tree and related data structures. Formalization
          of how to deal with hierarchical data structures seems to be relevant as
          programmers of any level of skill working in any given field is likely
          to need such a structure at one point.
        </p></div><div class="section" id="tree.preamble.motivation_and_scope.is_it_based_on_existing_practice"><div class="titlepage"><div><div><h4 class="title">1.2.3.&#160;<a class="link" href="#tree.preamble.motivation_and_scope.is_it_based_on_existing_practice" title="1.2.3.&#160;Is it based on existing practice?">Is
        it based on existing practice?</a></h4></div></div></div><p>
          No; this proposal originates in an effort to create a generic tree container
          component for <a href="http://www.boost.org" target="_top">Boost</a> in the course
          of <a href="https://developers.google.com/open-source/soc/2006/#boost" target="_top">Google
          Summer of Code&#8482; 2006</a>, so at the time of this writing, implementation
          work is still unfinished and, however inspired by and striving to avoid
          past issues and such ones arising from current implementation efforts (see
          below) it is, it has not been used in practice yet.
        </p></div><div class="section" id="tree.preamble.motivation_and_scope.is_there_a_reference_implementat"><div class="titlepage"><div><div><h4 class="title">1.2.4.&#160;<a class="link" href="#tree.preamble.motivation_and_scope.is_there_a_reference_implementat" title="1.2.4.&#160;Is there a reference implementation?">Is
        there a reference implementation?</a></h4></div></div></div><p>
          Yes; the current state is available from <a href="https://github.com/grafikrobot/boost-tree" target="_top">https://github.com/grafikrobot/boost-tree</a>.
        </p></div></div><div class="section" id="tree.preamble.impact_on_the_standard"><div class="titlepage"><div><div><h3 class="title">1.3.&#160;<a class="link" href="#tree.preamble.impact_on_the_standard" title="1.3.&#160;Impact on the Standard">Impact on the Standard</a></h3></div></div></div><div class="section" id="tree.preamble.impact_on_the_standard.what_does_it_depend_on_and_what_"><div class="titlepage"><div><div><h4 class="title">1.3.1.&#160;<a class="link" href="#tree.preamble.impact_on_the_standard.what_does_it_depend_on_and_what_" title="1.3.1.&#160;What does it depend on, and what depends on it?">What
        does it depend on, and what depends on it?</a></h4></div></div></div><p>
          It depends on some standard library components, such as <code class="literal">std::allocator</code>
          which is used as the default allocator template argument at some points.
          Concepts like allocators or iterators are reused and in some cases adapted.
        </p></div><div class="section" id="tree.preamble.impact_on_the_standard.is_it_a_pure_extension_or_does_i"><div class="titlepage"><div><div><h4 class="title">1.3.2.&#160;<a class="link" href="#tree.preamble.impact_on_the_standard.is_it_a_pure_extension_or_does_i" title="1.3.2.&#160;Is it a pure extension, or does it require changes to standard components?">Is
        it a pure extension, or does it require changes to standard components?</a></h4></div></div></div><p>
          Most of the proposed library is a pure extension.
        </p><p>
          Some extensions to <code class="literal">&lt;algorithm&gt;</code> and to <code class="literal">&lt;iterator&gt;</code>
          are proposed.
        </p><p>
          Additionally, while not proposed herein, it has sometimes been suggested
          to add a template parameter to the STL associative containers <code class="literal">set</code>,
          <code class="literal">multiset</code>, <code class="literal">map</code>, and <code class="literal">multimap</code>
          (and possibly an argument to their constructors) specifying a policy for
          storing elements, or, more concretely, what tree. The balancers presented
          in this proposal would lend themselves to such use. Indicating what type
          of balanced hierarchy to use for associative containers would create some
          amount of symmetry to <code class="literal">unordered</code> containers that allow
          specification of a hash functor; it is however a momentous decision in
          which position to put such a parameter. The same position as for <code class="literal">unordered</code>
          containers (before the comparison functor) would require changes in existing
          code; making it the last parameter (after the allocator) would allow existing
          code to remain unchanged, but seems somewhat irritating when compared to
          <code class="literal">unordered</code> containers.
        </p></div><div class="section" id="tree.preamble.impact_on_the_standard.can_it_be_implemented_using_toda"><div class="titlepage"><div><div><h4 class="title">1.3.3.&#160;<a class="link" href="#tree.preamble.impact_on_the_standard.can_it_be_implemented_using_toda" title="1.3.3.&#160;Can it be implemented using today's compilers, or does it require language features that will only be available as part of C++11">Can
        it be implemented using today's compilers, or does it require language features
        that will only be available as part of C++11</a></h4></div></div></div><p>
          It can be, and partly has been, implemented with today's compilers.
        </p><p>
          Note that it might be worthwhile to investigate if the present Container
          concept should be modified so that it only covers the requirements as of
          paragraph 2 of section <a href="#hierarchy.req" target="_top">[hierarchy.req.general]</a>
          of this proposal, which correspond to the current Container concept with
          the exception of any expressions that implicitly assume linear internal
          structure and outsource those to a "Linear Container" concept
          as similarly formalized in the <a href="http://boost.org/libs/range/doc/range.html" target="_top">Boost
          Range concept</a> (<a href="http://boost.org/libs/range/doc/range.html" target="_top">http://boost.org/libs/range/doc/range.html</a>)
          externally to the Standard.
        </p></div></div><div class="section" id="tree.preamble.important_design_decisions"><div class="titlepage"><div><div><h3 class="title">1.4.&#160;<a class="link" href="#tree.preamble.important_design_decisions" title="1.4.&#160;Important Design Decisions">Important Design
      Decisions</a></h3></div></div></div><div class="section" id="tree.preamble.important_design_decisions.why_did_you_choose_the_specific_"><div class="titlepage"><div><div><h4 class="title">1.4.1.&#160;<a class="link" href="#tree.preamble.important_design_decisions.why_did_you_choose_the_specific_" title="1.4.1.&#160;Why did you choose the specific design that you did?">Why
        did you choose the specific design that you did?</a></h4></div></div></div><p>
          One of the most important assets of the present design is the cursor concept
          as a hierarchical continuation to the STL's iterator concept, and the externally
          defined range concept. Among their benefits, cursors allow to handle both
          client data access, by dereference, and subtree access while hiding the
          normally underlying node structure and providing a uniform interface to
          algorithms that are thus enabled to deal with a number of different kinds
          of trees. On the other hand, this abstraction achieves independence of
          implementation details, such as nodes for storage in many cases, allowing
          the underlying concepts to be applicable to other possible implementations
          as well.
        </p></div><div class="section" id="tree.preamble.important_design_decisions.what_alternatives_did_you_consid"><div class="titlepage"><div><div><h4 class="title">1.4.2.&#160;<a class="link" href="#tree.preamble.important_design_decisions.what_alternatives_did_you_consid" title="1.4.2.&#160;What alternatives did you consider, and what are the tradeoffs?">What
        alternatives did you consider, and what are the tradeoffs?</a></h4></div></div></div><h6 id="tree.preamble.important_design_decisions.what_alternatives_did_you_consid.h0">
          <span id="tree.preamble.important_design_decisions.what_alternatives_did_you_consid.trees_of_trees" class="phrase"></span><a class="link" href="#tree.preamble.important_design_decisions.what_alternatives_did_you_consid.trees_of_trees">Trees
          of trees</a>
        </h6><p>
          Trees, being recursively defined data structures, seem to somewhat lend
          themselves to recursive implementation, i.e. declaring them in a way so
          they consist of a client value part and a certain number of trees in turn
          (as e.g. in case of <a class="link" href="#ref.haas">[haas]</a>). Such an approach
          would allow for uniform treatment of the subtrees, but would duplicate
          allocators and imply structure that need not be present. The tree, like
          existing STL containers, should be responsible for data representation
          and storage.
        </p><h6 id="tree.preamble.important_design_decisions.what_alternatives_did_you_consid.h1">
          <span id="tree.preamble.important_design_decisions.what_alternatives_did_you_consid.augmentors_balancers_as_policies" class="phrase"></span><a class="link" href="#tree.preamble.important_design_decisions.what_alternatives_did_you_consid.augmentors_balancers_as_policies">Augmentors/balancers
          as policies</a>
        </h6><p>
          Inspired by <a class="link" href="#ref.austern">[austern]</a> and <a class="link" href="#ref.dreizin">[dreizin]</a>,
          the original approach undertaken when working on the reference implementation
          was to pass policy template arguments to template class <code class="literal">binary_tree</code>.
          While reproducing the (otherwise unbalanced) tree/cursor interface seemed
          logical at first, it turned out that this was conceptually not entirely
          clean, as e.g. it preferred one type of linear order, namely inorder, over
          the others by putting such strong focus on inorder-invariant balancing
          and its possible applications; also, balancing and augmenting metadata
          would inevitably have been much more visible. It seemed more appropriate
          to have different balancing adaptors and augmenting adaptors that would
          replicate the interface to do that work.
        </p></div><div class="section" id="tree.preamble.important_design_decisions.what_are_the_consequences_of_you"><div class="titlepage"><div><div><h4 class="title">1.4.3.&#160;<a class="link" href="#tree.preamble.important_design_decisions.what_are_the_consequences_of_you" title="1.4.3.&#160;What are the consequences of your choices, for users and implementors?">What
        are the consequences of your choices, for users and implementors?</a></h4></div></div></div><p>
          As focus was put on versatility and comprehensiveness, we hope users will
          find this a powerful framework that covers most important aspects of dealing
          with hierarchical data structures in a rather intuitive way, once they
          have adapted to the notion of cursors which, although being the interface
          relevant portion of the well-known node implementation of trees, partly
          diverge in their usage from plain node objects.
        </p><p>
          Wherever reasonably possible, strong time complexity guarantees are given,
          which mostly, while trying not to require much space overhead, demand implementations
          that make use of any time and space saving techniques available (e.g. using
          arrays for both children of a binary tree node, see e.g. <a class="link" href="#ref.austern">[austern]</a>),
          which may partly restrict implementors to one "proper" way of
          doing things.
        </p></div><div class="section" id="tree.preamble.important_design_decisions.what_decisions_are_left_up_to_im"><div class="titlepage"><div><div><h4 class="title">1.4.4.&#160;<a class="link" href="#tree.preamble.important_design_decisions.what_decisions_are_left_up_to_im" title="1.4.4.&#160;What decisions are left up to implementors?">What
        decisions are left up to implementors?</a></h4></div></div></div><p>
          Most of the requirements for the library components presented in this proposal
          are rather tightly formulated in order to allow for them being both efficient
          and general enough. It is however hoped that the conceptual abstraction
          of hierarchies and cursors may be of general use, also allowing for more
          specific implementations where required (although probably not as part
          of the library; ideally comparable to the role of containers and iterators
          in modern C++ code).
        </p></div><div class="section" id="tree.preamble.important_design_decisions.if_there_are_any_similar_librari"><div class="titlepage"><div><div><h4 class="title">1.4.5.&#160;<a class="link" href="#tree.preamble.important_design_decisions.if_there_are_any_similar_librari" title="1.4.5.&#160;If there are any similar libraries in use, how do their design decisions compare to yours?">If
        there are any similar libraries in use, how do their design decisions compare
        to yours?</a></h4></div></div></div><p>
          Trees, having attracted much attention in the C++ community, are found
          in various implementations and as subjects of a number of papers. Contrary
          to the present proposal, practically all of them deal either with trees
          as used for sorted associative containers (with logarithmic time complexity
          for more relevant operations, achieved by some sort of balancing; examples
          are <a class="link" href="#ref.dreizin">[dreizin]</a>, <a class="link" href="#ref.ekman">[ekman]</a>
          and <a class="link" href="#ref.karas">[karas]</a>; plus, most current STL implementations
          use a red-black tree as their associative containers' base) or with what
          we call "external" hierarchies in the following (whose structure
          is dictated e.g. by a file system directory tree, an XML file or an AST;
          see e.g. <a class="link" href="#ref.gottschlich">[gottschlich]</a>, <a class="link" href="#ref.haas">[haas]</a>,
          <a class="link" href="#ref.parent">[parent]</a> and <a class="link" href="#ref.peeters">[peeters]</a>),
          but rarely both fields of application.
        </p><p>
          Approaches as found in <a class="link" href="#ref.austern">[austern]</a> go
          some steps further and have provided valuable inspiration for this project,
          but still do not formalize anything similar as the cursor-based interface
          in this proposal for dealing with a tree's contents.
        </p><p>
          The <a href="http://www.boost.org/libs/graph/" target="_top">BGL</a>, finally,
          deals with graphs that are even more general than hierarchical ones, which
          does not allow them to profit from specific hierarchy properties as much
          as the ones presented in this proposal. Making cursors logical extensions
          of iterators would probably also have been more difficult with a BGL-based
          approach.
        </p></div></div><div class="section" id="tree.preamble.future_directions"><div class="titlepage"><div><div><h3 class="title">1.5.&#160;<a class="link" href="#tree.preamble.future_directions" title="1.5.&#160;Future Directions">Future Directions</a></h3></div></div></div><p>
        While it is hoped that the current proposal somewhat reunites balanced binary
        trees, B-trees and "external" hierarchies, which should also facilitate
        work with some higher-level structures (e.g. n-ary trees to implement tries),
        some of those higher-level components might be an interesting feature to
        add to the library, such as patricia tries or ternary search tries.
      </p></div></div><div class="section std_proposal" id="tree.proposal"><div class="titlepage"><div><div><h2 class="title" style="clear: both">2.&#160;<a class="link" href="#tree.proposal" title="2.&#160;Proposed Text">Proposed Text</a></h2></div></div></div><div class="note"><h3 class="title">Note</h3><p>
      Notes that are not part of the proposed text appear in gray boxes.
    </p></div><div class="section std_section" id="tree.proposal.containers"><div class="titlepage"><div><div><h3 class="title">23.&#160;<a class="link" href="#tree.proposal.containers" title="23.&#160;Container library [containers]">Container library <span class="std_section_label">[containers]</span></a></h3></div></div></div><div class="section std_section" id="tree.proposal.hierarchy"><div class="titlepage"><div><div><h4 class="title">23.7.&#160;<a class="link" href="#tree.proposal.hierarchy" title="23.7.&#160;Hierarchy containers [hierarchy]">Hierarchy
  containers <span class="std_section_label">[hierarchy]</span></a></h4></div></div></div><div class="section" id="tree.req"><div class="titlepage"><div><div><h5 class="title">23.7.1.&#160;<a class="link" href="#tree.req" title="23.7.1.&#160;Hierarchy containers requirements [hierarchy.req]">Hierarchy containers requirements <span class="std_section_label">[hierarchy.req]</span></a></h5></div></div></div><p>
      In this section's tables, <code class="literal">X</code> denotes a hierarchy class,
      <code class="literal">a</code> denotes a value of <code class="literal">X</code> containing elements
      of type <code class="literal">T</code>, <code class="literal">c</code> denotes a valid, non-on-top
      cursor satisfying input cursor requirements, <code class="literal">p</code> denotes a
      valid, non-on-top cursor to <code class="literal">a</code>, <code class="literal">q</code> denotes
      a valid, dereferenceable cursor to <code class="literal">a</code>, <code class="literal">t</code>
      denotes an lvalue or a const rvalue of <code class="literal">X::value_type</code>, and
      <code class="literal">rv</code> denotes a non-const rvalue of <code class="literal">X::value_type</code>.
      <code class="literal">Args</code> denotes a template parameter pack; <code class="literal">args</code>
      denotes a function parameter pack with the pattern <code class="literal">Args&amp;&amp;</code>.
    </p><div class="section" id="tree.req.general"><div class="titlepage"><div><div><h6 class="title">23.7.1.1.&#160;<a class="link" href="#tree.req.general" title="23.7.1.1.&#160;General hierarchy requirements [hier.req.general]">General hierarchy requirements <span class="std_section_label">[hier.req.general]</span></a></h6></div></div></div><div class="simplesect std_requisite" id="idp4622592"><div class="titlepage"></div><p>
        A hierarchy is an object that stores a finite set of objects, all of the
        same type, in a hierarchical manner, i.e. as a rooted ordered connected acyclic
        graph. Hierarchies introduce a cursor concept for navigation instead of iterators.
        The library provides two kinds of native hierarchies: <code class="literal">binary_tree</code>,
        and <code class="literal">nary_tree</code>, along with hierarchy-yielding hierarchy
        adaptors <code class="literal">forest_tree</code>, and <code class="literal">multiway_tree</code>.
      </p></div><div class="simplesect std_requisite" id="idp4626416"><div class="titlepage"></div><p>
        Hierarchy containers conform to the requirements of Containers ([container.requirements]),
        except that the expressions in Table 1 are not required to be valid, where
        <code class="literal">a</code> and <code class="literal">b</code> denote values of a type <code class="literal">X</code>,
        and <code class="literal">X</code> is a hierarchy container class:
      </p><div class="table" id="tree.req.general.table1"><div class="table-title">Table&#160;1.&#160;Container requirements that are not required for hierarchy containers</div><div class="table-contents"><table class="table" summary="Container requirements that are not required for hierarchy containers"><colgroup><col></colgroup><thead><tr><th>
                <p>
                  unsupported expression
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="literal">X::iterator</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">X::const_iterator</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">X::difference_type</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.begin()</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.end()</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.cbegin()</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.cend()</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a == b</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a != b</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">X::reverse_iterator</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">X::const_reverse_iterator</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.rbegin()</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.rend()</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.crbegin()</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.crend()</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a &lt; b</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a &gt; b</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a &lt;= b</code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a &gt;= b</code>
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"></div><div class="simplesect std_requisite" id="idp4667696"><div class="titlepage"></div><p>
        Non-constant complexity requirements in this clause are stated in one of
        a number of possible different ways: unless specified otherwise, they are
        expressed in terms of the number of operations <code class="literal">n</code>, which
        stands for the total number of elements in the hierarchy; in some cases,
        however, they are stated in terms of another value.
      </p><div class="table" id="tree.req.general.table2"><div class="table-title">Table&#160;2.&#160;Hierarchy requirements (in addition to container)</div><div class="table-contents"><table class="table" summary="Hierarchy requirements (in addition to container)"><colgroup><col><col><col><col></colgroup><thead><tr><th>
                <p>
                  expression
                </p>
              </th><th>
                <p>
                  return type
                </p>
              </th><th>
                <p>
                  assertion/note<br> pre/post-condition
                </p>
              </th><th>
                <p>
                  complexity
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="literal">X::cursor</code>
                </p>
              </td><td>
                <p>
                  cursor type pointing to <code class="literal">T</code>
                </p>
              </td><td>
                <p>
                  any cursor category
                </p>
              </td><td>
                <p>
                  compile time
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">X::const_cursor</code>
                </p>
              </td><td>
                <p>
                  cursor type pointing to <code class="literal">const T</code>
                </p>
              </td><td>
                <p>
                  any cursor category
                </p>
              </td><td>
                <p>
                  compile time
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.root()</code>
                </p>
              </td><td>
                <p>
                  <code class="literal">cursor</code> for mutable <code class="literal">a</code>; <br>
                  <code class="literal">const_cursor</code> for constant <code class="literal">a</code>
                </p>
              </td><td>
                <p>
                  &#160;
                </p>
              </td><td>
                <p>
                  constant
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.croot()</code>
                </p>
              </td><td>
                <p>
                  <code class="literal">const_cursor</code>
                </p>
              </td><td>
                <p>
                  &#160;
                </p>
              </td><td>
                <p>
                  constant
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.shoot()</code>
                </p>
              </td><td>
                <p>
                  <code class="literal">cursor</code> for mutable <code class="literal">a</code>; <br>
                  <code class="literal">const_cursor</code> for constant <code class="literal">a</code>
                </p>
              </td><td>
                <p>
                  &#160;
                </p>
              </td><td>
                <p>
                  (Note A)
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.cshoot()</code>
                </p>
              </td><td>
                <p>
                  <code class="literal">const_cursor</code>
                </p>
              </td><td>
                <p>
                  &#160;
                </p>
              </td><td>
                <p>
                  (Note A)
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">typename X::template rebind&lt;U&gt;::other</code>
                </p>
              </td><td>
                <p>
                  <code class="literal">Y</code>
                </p>
              </td><td>
                <p>
                  For all <code class="literal">U</code> (including <code class="literal">T</code>),
                  <code class="literal">Y::template rebind&lt;T&gt;::other</code> is <code class="literal">X</code>.
                </p>
              </td><td>
                <p>
                  compile time
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"><p>
        Notes: Those entries marked "(Note A)" shall have at worst linear
        complexity. See the individual hierarchy containers for specific complexity.
      </p></div><div class="simplesect std_requisite" id="idp4716544"><div class="titlepage"></div><p>
        <code class="literal">root()</code> and <code class="literal">croot()</code> return a cursor
        which is the on-top value for the hierarchy. <code class="literal">shoot()</code> and
        <code class="literal">cshoot()</code> return a cursor which is the past-the-end value
        that is found one past the hierarchy's rightmost element. If the hierarchy
        is empty, then <code class="literal">root() == shoot();</code>
      </p></div><div class="simplesect std_requisite" id="idp4720816"><div class="titlepage"></div><p>
        Copy constructors for all hierarchy types defined in this clause copy the
        allocator argument from their respective first parameters. All other constructors
        for these hierarchy types take an <code class="literal">Allocator&amp;</code> argument
        (20.6.9). A copy of this argument is used for any memory allocation performed,
        by these constructors and by all member functions, during the lifetime of
        each hierarchy object. In all hierarchy types defined in this clause, the
        member <code class="literal">get_allocator()</code> returns a copy of the <code class="literal">Allocator</code>
        object used to construct the hierarchy.
      </p></div><div class="simplesect std_requisite" id="idp4724208"><div class="titlepage"></div><p>
        The member class template <code class="literal">rebind</code> in the table above is
        effectively a typedef template: if the name <code class="literal">Hierarchy</code>
        is bound to <code class="literal">SomeHierarchy&lt;T&gt;</code>, then <code class="literal">Hierarchy::rebind&lt;U&gt;::other</code>
        is the same type as <code class="literal">SomeHierarchy&lt;U&gt;</code>. Additionally,
        because of the related assertion, given <code class="literal">SomeHierarchy&lt;T,R0,...,Rn&gt;</code>
        for all template arguments present is bound to the name <code class="literal">Hierarchy</code>,
        then <code class="literal">Hierarchy::rebind&lt;U&gt;::other</code> is the same type
        as <code class="literal">SomeHierarchy&lt;U,S0,...,Sn&gt;</code> such that the types
        <code class="literal">S0</code> through <code class="literal">Sn</code> are the same as <code class="literal">R0</code>
        through <code class="literal">Rn</code>, respectively, when <code class="literal">U</code> is
        the same type as <code class="literal">T</code>.
      </p></div><div class="simplesect std_requisite" id="idp4734560"><div class="titlepage"></div><p>
        A hierarchy satisfying the requirements shown in Table 3 is called a <span class="emphasis"><em>mutable
        hierarchy</em></span>.
      </p><div class="table" id="tree.req.general.table3"><div class="table-title">Table&#160;3.&#160;Mutable hierarchy requirements</div><div class="table-contents"><table class="table" summary="Mutable hierarchy requirements"><colgroup><col><col><col><col></colgroup><thead><tr><th>
                <p>
                  expression
                </p>
              </th><th>
                <p>
                  return type
                </p>
              </th><th>
                <p>
                  assertion/note <br> pre/post-condition
                </p>
              </th><th>
                <p>
                  complexity
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">emplace</span><span class="special">(</span><span class="identifier">p</span><span class="special">,</span>
                  <span class="identifier">args</span><span class="special">);</span></code>
                </p>
              </td><td>
                <p>
                  <code class="literal">cursor</code>
                </p>
              </td><td>
                <p>
                  <span class="emphasis"><em>Requires:</em></span> <code class="literal">T</code> is <code class="literal">EmplaceConstructable</code>
                  into X from <code class="literal">args</code>, T is also <code class="literal">MoveInsertable</code>
                  into <code class="literal">X</code> and <code class="literal">MoveAssignable</code>.
                  <br> <span class="emphasis"><em>Effects:</em></span> Inserts an object of type
                  <code class="literal">T</code> constructed with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">forward</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">&gt;(</span><span class="identifier">args</span><span class="special">)...</span></code> before <code class="literal">p</code>.
                </p>
              </td><td>
                <p>
                  (Note A)
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">p</span><span class="special">,</span><span class="identifier">t</span><span class="special">)</span></code>
                </p>
              </td><td>
                <p>
                  <code class="literal">cursor</code>
                </p>
              </td><td>
                <p>
                  <span class="emphasis"><em>Requires:</em></span> <code class="literal">T</code> shall be <code class="literal">CopyInsertable</code>
                  into <code class="literal">X</code>. <span class="emphasis"><em>Effects:</em></span> Inserts
                  a copy of <code class="literal">t</code> before <code class="literal">p</code>.
                </p>
              </td><td>
                <p>
                  (Note A)
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">p</span><span class="special">,</span><span class="identifier">rv</span><span class="special">)</span></code>
                </p>
              </td><td>
                <p>
                  <code class="literal">cursor</code>
                </p>
              </td><td>
                <p>
                  <span class="emphasis"><em>Requires:</em></span> <code class="literal">T</code> shall be <code class="literal">MoveInsertable</code>
                  into <code class="literal">X</code>. <span class="emphasis"><em>Effects:</em></span> Inserts
                  a copy of <code class="literal">rv</code> before <code class="literal">p</code>.
                </p>
              </td><td>
                <p>
                  (Note A)
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">clear</span><span class="special">(</span><span class="identifier">q</span><span class="special">)</span></code>
                </p>
              </td><td>
                <p>
                  <code class="literal">void</code>
                </p>
              </td><td>
                <p>
                  <span class="emphasis"><em>Effects:</em></span> Deletes the subtree of <code class="literal">q</code>
                  and the element <code class="literal">q</code> points to. <br> pre: <code class="literal">q</code>
                  is dereferenceable.
                </p>
              </td><td>
                <p>
                  Shall be at worst linear in the the number of elements in the subtree
                  of <code class="literal">q</code> plus the distance to <code class="literal">q</code>'s
                  parent's <code class="literal">end()</code>.
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">clear</span><span class="special">()</span></code>
                </p>
              </td><td>
                <p>
                  <code class="literal">void</code>
                </p>
              </td><td>
                <p>
                  <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="keyword">while</span>
                  <span class="special">(</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">size</span><span class="special">())</span> <span class="identifier">clear</span><span class="special">(</span><span class="identifier">a</span><span class="special">.</span><span class="identifier">begin</span><span class="special">());</span></code> <br> post: <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span>
                  <span class="special">==</span> <span class="number">0</span></code>
                </p>
              </td><td>
                <p>
                  (Note A)
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"><p>
        Notes: Those entries marked "(Note A)" shall have at worst linear
        complexity. See the individual hierarchy containers for specific complexity.
      </p></div><div class="simplesect std_requisite" id="idp4815088"><div class="titlepage"></div><p>
        The cursor returned from <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">p</span><span class="special">,</span>
        <span class="identifier">t</span><span class="special">)</span></code>
        points to the copy of <code class="literal">t</code> inserted into <code class="literal">a</code>.
        Its parent cursor is the same as that of <code class="literal">p</code>.
      </p></div><div class="simplesect std_requisite" id="idp4822416"><div class="titlepage"></div><p>
        The cursor returned from <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">p</span><span class="special">,</span>
        <span class="identifier">rv</span><span class="special">)</span></code>
        points to the copy of <code class="literal">rv</code> inserted into <code class="literal">a</code>.
        Its parent cursor is the same as that of <code class="literal">p</code>.
      </p></div><div class="simplesect std_requisite" id="idp4829744"><div class="titlepage"></div><p>
        The cursor returnd from <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">emplace</span><span class="special">(</span><span class="identifier">p</span><span class="special">,</span>
        <span class="identifier">args</span><span class="special">)</span></code>
        points to the new element constructed from <code class="literal">args</code> into
        <code class="literal">a</code>. Its parent cursor is the same as that of <code class="literal">p</code>.
      </p></div></div></div><div class="section" id="tree.plain"><div class="titlepage"><div><div><h5 class="title">23.7.2.&#160;<a class="link" href="#tree.plain" title="23.7.2.&#160;Plain hierarchies [hierarchy.plain]">Plain hierarchies <span class="std_section_label">[hierarchy.plain]</span></a></h5></div></div></div><div class="simplesect std_requisite" id="idp4839024"><div class="titlepage"></div><p>
      A hierarchy is called a <span class="emphasis"><em>plain hierarchy</em></span> if its <code class="literal">cursor</code>
      and <code class="literal">const_cursor</code> types satisfy the requirements of a plain
      cursor.
    </p></div><div class="simplesect std_requisite" id="idp4841680"><div class="titlepage"></div><p>
      The library provides one native kind of plain hierarchy, <code class="literal">nary_tree</code>,
      and a hierarchy adaptor that in turn yields a plain hierarchy, <code class="literal">forest_tree</code>.
    </p></div><div class="simplesect std_requisite" id="idp4844048"><div class="titlepage"></div><p>
      For a mutable plain hierarchy, the following expressions as shown in Table
      4, are additionally required to be valid:
    </p><div class="table" id="tree.plain.table4"><div class="table-title">Table&#160;4.&#160;Plain hierarchy requirements</div><div class="table-contents"><table class="table" summary="Plain hierarchy requirements"><colgroup><col><col><col><col></colgroup><thead><tr><th>
              <p>
                expression
              </p>
            </th><th>
              <p>
                return type
              </p>
            </th><th>
              <p>
                assertion/note <br> pre/post-condition
              </p>
            </th><th>
              <p>
                complexity
              </p>
            </th></tr></thead><tbody><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">p</span><span class="special">,</span><span class="identifier">c</span><span class="special">)</span></code>
              </p>
            </td><td>
              <p>
                <code class="literal">cursor</code>
              </p>
            </td><td>
              <p>
                <span class="emphasis"><em>Requires:</em></span> <code class="literal">T</code> shall be <code class="literal">CopyInsertable</code>
                into <code class="literal">X</code> <br> <span class="emphasis"><em>Effects:</em></span> Inserts
                a copy of the subtree of <code class="literal">c</code> before <code class="literal">p</code>.
                <br> pre: <code class="literal">c</code> is dereferenceable.
              </p>
            </td><td>
              <p>
                Shall be at worst linear in the number of elements in the subtree
                of <code class="literal">c</code> plus the distance to <code class="literal">p</code>'s
                parent's <code class="literal">end()</code>.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">insert_above</span><span class="special">(</span><span class="identifier">p</span><span class="special">,</span><span class="identifier">t</span><span class="special">)</span></code>
              </p>
            </td><td>
              <p>
                <code class="literal">cursor</code>
              </p>
            </td><td>
              <p>
                <span class="emphasis"><em>Requires:</em></span> <code class="literal">T</code> shall be <code class="literal">CopyInsertable</code>
                into <code class="literal">X</code> <br> <span class="emphasis"><em>Effects:</em></span> Inserts
                a copy of <code class="literal">t</code> as a child of <code class="literal">p</code>'s
                parent; the new child becomes new parent of <code class="literal">p</code>
                and its siblings. <br> pre: <code class="literal">p</code> is dereferenceable.
              </p>
            </td><td>
              <p>
                Linear in the number <code class="literal">p</code>'s siblings.
              </p>
            </td></tr><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">insert_above</span><span class="special">(</span><span class="identifier">p</span><span class="special">,</span><span class="identifier">rv</span><span class="special">)</span></code>
              </p>
            </td><td>
              <p>
                <code class="literal">cursor</code>
              </p>
            </td><td>
              <p>
                <span class="emphasis"><em>Requires:</em></span> <code class="literal">T</code> shall be <code class="literal">MoveInsertable</code>
                into <code class="literal">X</code>. <span class="emphasis"><em>Effects:</em></span> Inserts
                a copy of <code class="literal">rv</code> as a child of <code class="literal">p</code>'s
                parent; the new child becomes the parent of <code class="literal">p</code>
                and its siblings. <br> pre: <code class="literal">p</code> is dereferenceable.
              </p>
            </td><td>
              <p>
                Linear in the number <code class="literal">p</code>'s siblings.
              </p>
            </td></tr></tbody></table></div></div><br class="table-break"></div><div class="simplesect std_requisite" id="idp4895728"><div class="titlepage"></div><p>
      The cursor returned from <code class="literal">a.insert(p,c)</code> points to the copy
      of the element that <code class="literal">c</code> points to, inserted into <code class="literal">a</code>.
      Its parent cursor is the same as that of <code class="literal">p</code>.
    </p></div></div><div class="section" id="tree.multiway"><div class="titlepage"><div><div><h5 class="title">23.7.3.&#160;<a class="link" href="#tree.multiway" title="23.7.3.&#160;Multiway hierarchies [hierarchy.multiway]">Multiway hierarchies <span class="std_section_label">[hierarchy.multiway]</span></a></h5></div></div></div><div class="simplesect std_requisite" id="idp4901040"><div class="titlepage"></div><p>
      A hierarchy is called a <span class="emphasis"><em>multiway hierarchy</em></span> if its <code class="literal">cursor</code>
      and <code class="literal">const_cursor</code> types satisfy the requirements of a multiway
      cursor.
    </p></div><div class="simplesect std_requisite" id="idp4903712"><div class="titlepage"></div><p>
      The library provides one native kind of multiway hierarchy, <code class="literal">binary_tree</code>,
      and a hierarchy adaptor that in turn yields a multiway hierarchy, <code class="literal">multiway_tree</code>.
    </p></div><div class="simplesect std_requisite" id="idp4906080"><div class="titlepage"></div><p>
      For a mutable multiway hierarchy, the semantics of some expressions from Table
      3 are modified as shown in Table 5.
    </p><div class="table" id="tree.multiway.table5"><div class="table-title">Table&#160;5.&#160;Multiway hierarchy requirements</div><div class="table-contents"><table class="table" summary="Multiway hierarchy requirements"><colgroup><col><col><col><col></colgroup><thead><tr><th>
              <p>
                expression
              </p>
            </th><th>
              <p>
                return type
              </p>
            </th><th>
              <p>
                assertion/note <br> pre/post-condition
              </p>
            </th><th>
              <p>
                complexity
              </p>
            </th></tr></thead><tbody><tr><td>
              <p>
                <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">clear</span><span class="special">(</span><span class="identifier">q</span><span class="special">)</span></code>
              </p>
            </td><td>
              <p>
                <code class="literal">void</code>
              </p>
            </td><td>
              <p>
                Deletes the subtree of <code class="literal">q</code>.<br> If <code class="literal">q</code>
                is dereferenceable, the expression also deletes the element <code class="literal">q</code>
                points to. <br> If <code class="literal">q</code> is past-the-end, the expression
                deletes the element <code class="literal">q</code>'s predecessor points to.
                <br> If after either of these steps <code class="literal">q</code> has only
                a non-empty past-the-end child, that child's children become <code class="literal">q</code>'s
                children instead. Finally, that child is deleted. <br> pre: <code class="literal">q</code>
                is internal.
              </p>
            </td><td>
              <p>
                Shall be at worst linear in the the number of elements in the subtree
                of <code class="literal">c</code> plus the distance to <code class="literal">p</code>'s
                parent's <code class="literal">end()</code>.
              </p>
            </td></tr></tbody></table></div></div><br class="table-break"></div></div><div class="section" id="tree.tree"><div class="titlepage"><div><div><h5 class="title">23.7.4.&#160;<a class="link" href="#tree.tree" title="23.7.4.&#160;Trees [hierarchy.tree]">Trees <span class="std_section_label">[hierarchy.tree]</span></a></h5></div></div></div><div class="simplesect std_requisite" id="idp4930928"><div class="titlepage"></div><p>
      Headers <code class="literal">&lt;binary_tree&gt;</code>, and <code class="literal">&lt;nary_tree&gt;</code>
      define template classes that meet the requirements for hierarchies.
    </p><p>
      <span class="bold"><strong>Header <code class="literal">&lt;binary_tree&gt;</code> synopsis</strong></span>
    </p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">binary_tree</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;,</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;);</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
      <span class="bold"><strong>Header <code class="literal">&lt;nary_tree&gt;</code> synopsis</strong></span>
    </p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">nary_tree</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;,</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;);</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" id="tree.tree.bintree"><div class="titlepage"><div><div><h6 class="title">23.7.4.1.&#160;<a class="link" href="#tree.tree.bintree" title="23.7.4.1.&#160;Class template binary_tree [hierarchy.bintree]">Class template <code class="literal">binary_tree</code>
      <span class="std_section_label">[hierarchy.bintree]</span></a></h6></div></div></div><div class="section" id="tree.tree.bintree.overview"><div class="titlepage"><div><div><h6 class="title">23.7.4.1.1.&#160;<a class="link" href="#tree.tree.bintree.overview" title="23.7.4.1.1.&#160;Class template binary_tree overview [bintree.overview]">Class template <code class="literal">binary_tree</code>
        overview <span class="std_section_label">[bintree.overview]</span></a></h6></div></div></div><p>
          A <code class="literal">binary_tree</code> is a kind of hierarchy that satisfies
          multiway hierarchy requirements. Additionally, it supports (inorder-invariant)
          cursor rotation. Descriptions are provided here only for operations on
          <code class="literal">binary_tree</code> that are not described in one of these tables
          or for operations where there is additional semantic information.
        </p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span>
  <span class="keyword">class</span> <span class="identifier">binary_tree</span> <span class="special">{</span>
  <span class="keyword">public</span><span class="special">:</span>
    <span class="comment">// types:</span>
    <span class="keyword">typedef</span> <span class="identifier">value_type</span><span class="special">&amp;</span>                                   <span class="identifier">reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">&amp;</span>                             <span class="identifier">const_reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">cursor</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">const_cursor</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">size_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">difference_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">T</span>                                             <span class="identifier">value_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">Allocator</span>                                     <span class="identifier">allocator_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">allocator_traits</span><span class="special">&lt;</span><span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">pointer</span>              <span class="identifier">pointer</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">allocator_traits</span><span class="special">&lt;</span><span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">const_pointer</span>        <span class="identifier">const_pointer</span><span class="special">;</span>

    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">rebind</span> <span class="special">{</span>
      <span class="keyword">typedef</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Allocator</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">rebind</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">other</span> <span class="special">&gt;</span>
        <span class="identifier">other</span><span class="special">;</span>
    <span class="special">};</span>

    <span class="comment">// construct/copy/destroy:</span>
    <span class="keyword">explicit</span> <span class="identifier">binary_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">Allocator</span><span class="special">());</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
      <span class="identifier">binary_tree</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">,</span>
        <span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">Allocator</span><span class="special">());</span>
    <span class="identifier">binary_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&amp;);</span>
    <span class="identifier">binary_tree</span><span class="special">(</span><span class="identifier">binary_tree</span><span class="special">&amp;&amp;);</span>
    <span class="identifier">binary_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;);</span>
    <span class="identifier">binary_tree</span><span class="special">(</span><span class="identifier">binary_tree</span><span class="special">&amp;&amp;,</span> <span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;);</span>
    <span class="special">~</span><span class="identifier">binary_tree</span><span class="special">();</span>
    <span class="identifier">binary_tree</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&amp;);</span>
    <span class="identifier">binary_tree</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">binary_tree</span><span class="special">&amp;&amp;);</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
    <span class="identifier">Allocator</span> <span class="identifier">get_allocator</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

    <span class="comment">// cursors:</span>
    <span class="identifier">cursor</span>        <span class="identifier">root</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">root</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">croot</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">cursor</span>        <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">cshoot</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

    <span class="comment">// capacity:</span>
    <span class="keyword">bool</span>      <span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

    <span class="comment">// modifiers:</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;);</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
      <span class="identifier">cursor</span>  <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">rotate</span><span class="special">(</span><span class="identifier">const_cursor</span> <span class="identifier">position</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">swap</span><span class="special">(</span><span class="identifier">binary_tree</span><span class="special">&amp;);</span>
    <span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">();</span>
  <span class="special">};</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span>  <span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span>  <span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

  <span class="comment">// specialized algorithms:</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span>  <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" id="tree.tree.bintree.types"><div class="titlepage"><div><div><h6 class="title">23.7.4.1.2.&#160;<a class="link" href="#tree.tree.bintree.types" title="23.7.4.1.2.&#160;binary_tree types [bintree.types]"><code class="literal">binary_tree</code>
        types <span class="std_section_label">[bintree.types]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp5277328"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">cursor</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">const_cursor</span><span class="special">;</span>
</pre></div><div class="simplesect std_requisite" id="idp5282576"><div class="titlepage"></div><p>
          Both <code class="literal">cursor</code> and <code class="literal">const_cursor</code> have
          to fulfill the multiway cursor ([cursor.flavors]) and ascending random
          access cursor ([ascending.random.access.cursors]) requirements.
        </p></div><div class="simplesect std_requisite" id="idp5284960"><div class="titlepage"></div><p>
          Additionally, for any instance a of either type <code class="literal">cursor</code>
          or <code class="literal">const_cursor</code>, <code class="literal">a.max_size() == 1</code>.
        </p></div></div><div class="section" id="tree.tree.bintree.cons"><div class="titlepage"><div><div><h6 class="title">23.7.4.1.3.&#160;<a class="link" href="#tree.tree.bintree.cons" title="23.7.4.1.3.&#160;binary_tree constructors, copy, and assignment [bintree.cons]"><code class="literal">binary_tree</code>
        constructors, copy, and assignment <span class="std_section_label">[bintree.cons]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp5290144"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">binary_tree</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">Allocator</span><span class="special">());</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="identifier">binary_tree</span> <span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">,</span>
    <span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">Allocator</span><span class="special">());</span>
<span class="identifier">binary_tree</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">binary_tree</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5309152"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Complexity:</em></span> The constructor <code class="computeroutput"><span class="keyword">template</span>
          <span class="special">&lt;</span><span class="keyword">class</span>
          <span class="identifier">InputCursor</span><span class="special">&gt;</span>
          <span class="identifier">binary_tree</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">)</span></code> makes only <code class="literal">N</code> calls
          to the copy constructor of <code class="literal">T</code> (where <code class="literal">N</code>
          is the number of elements in <code class="literal">subtree</code>) and no reallocations
          if the cursor <code class="literal">subtree</code> is of (either descending or ascending)
          forward, bidirectional, or random access categories. It does at most <code class="literal">2N</code>
          calls to the copy constructor of <code class="literal">T</code> and <code class="literal">logN</code>
          reallocations if they are just cursors, since it is impossible to determine
          the size of <code class="literal">subtree</code> and then do copying.
        </p></div><div class="simplesect std_definition" id="idp5322032"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5329168"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Effects:</em></span>
        </p><pre class="programlisting"><span class="identifier">clear</span><span class="special">();</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">auto</span> <span class="identifier">v</span> <span class="special">:</span> <span class="identifier">subtree</span><span class="special">)</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">root</span><span class="special">().</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">v</span><span class="special">);</span>
</pre></div></div><div class="section" id="tree.tree.bintree.cursors"><div class="titlepage"><div><div><h6 class="title">23.7.4.1.4.&#160;<a class="link" href="#tree.tree.bintree.cursors" title="23.7.4.1.4.&#160;binary_tree cursors [bintree.cursors]"><code class="literal">binary_tree</code>
        cursors <span class="std_section_label">[bintree.cursors]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp5342384"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">cursor</span>        <span class="identifier">shoot</span><span class="special">();</span>
<span class="identifier">const_cursor</span>  <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">const_cursor</span>  <span class="identifier">cshoot</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp5350736"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Complexity:</em></span> constant
        </p></div></div><div class="section" id="tree.tree.bintree.modifiers"><div class="titlepage"><div><div><h6 class="title">23.7.4.1.5.&#160;<a class="link" href="#tree.tree.bintree.modifiers" title="23.7.4.1.5.&#160;binary_tree modifiers [bintree.modifiers]"><code class="literal">binary_tree</code>
        modifiers <span class="std_section_label">[bintree.modifiers]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp5354416"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">cursor</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="identifier">cursor</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="identifier">x</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5366992"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Notes:</em></span> Does not affect the validity of cursors and
          references.
        </p></div><div class="simplesect std_specification" id="idp5368448"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Effect:</em></span> Let <code class="literal">parent</code> be <code class="literal">position</code>'s
          parent; if <code class="computeroutput"><span class="identifier">parent</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">parent</span><span class="special">.</span><span class="identifier">max_size</span><span class="special">()</span></code>, insert a copy of <code class="literal">x</code>
          before <code class="literal">position</code>, as child of <code class="literal">parent</code>;
          Otherwise, if <code class="computeroutput"><span class="identifier">position</span><span class="special">.</span><span class="identifier">empty</span><span class="special">()</span></code>, insert a copy of <code class="literal">x</code>
          as child of <code class="literal">position</code>; and if <code class="computeroutput"><span class="special">!</span><span class="identifier">position</span><span class="special">.</span><span class="identifier">empty</span><span class="special">()</span></code>,
          insert a copy of <code class="literal">x</code> as parent of <code class="literal">position</code>'s
          current child, as new child of <code class="literal">position</code>.
        </p></div><div class="simplesect std_specification" id="idp5386240"><div class="titlepage"></div><p>
          Complexity: constant
        </p></div><div class="simplesect std_definition" id="idp5387232"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="identifier">cursor</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5396064"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Notes:</em></span> Does not affect the validity of cursors and
          references.
        </p></div><div class="simplesect std_specification" id="idp5397520"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Effects:</em></span> as above, substituting <code class="literal">InputCursor
          subtree</code> to insert instead of <code class="computeroutput"><span class="keyword">const</span>
          <span class="identifier">T</span><span class="special">&amp;</span>
          <span class="identifier">x</span></code>.
        </p></div><div class="simplesect std_specification" id="idp5402160"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Complexity:</em></span> linear in the number of elements in subtree.
        </p></div><div class="simplesect std_definition" id="idp5403600"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">rotate</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5407952"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Precondition:</em></span> <code class="literal">position</code> and its
          parent are internal and non-on-top
        </p></div><div class="simplesect std_specification" id="idp5410000"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Effects:</em></span> Performs a left tree rotation around the
          parent of <code class="literal">position</code> if <code class="computeroutput"><span class="identifier">position</span><span class="special">.</span><span class="identifier">parity</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span></code>
          or a right tree rotation if <code class="computeroutput"><span class="identifier">position</span><span class="special">.</span><span class="identifier">parity</span><span class="special">()</span> <span class="special">==</span> <span class="number">1</span></code>.
        </p></div><div class="simplesect std_specification" id="idp5419280"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Postcondition:</em></span> If <code class="computeroutput"><span class="identifier">par</span>
          <span class="special">==</span> <span class="identifier">position</span><span class="special">.</span><span class="identifier">parity</span><span class="special">()</span></code> as of before the rotation, then, after
          the rotation:
        </p><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p>
              <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span></code> yields the same value it yielded
              before the rotation
            </p></li><li class="listitem"><p>
              <code class="computeroutput"><span class="identifier">position</span><span class="special">.</span><span class="identifier">parity</span><span class="special">()</span>
              <span class="special">==</span> <span class="special">!</span><span class="identifier">par</span></code>
            </p></li><li class="listitem"><p>
              <code class="computeroutput"><span class="special">*(((</span><span class="identifier">position</span><span class="special">.</span><span class="identifier">begin</span><span class="special">())[</span><span class="identifier">par</span><span class="special">]).</span><span class="identifier">begin</span><span class="special">())</span></code> yields what <code class="computeroutput"><span class="special">*(</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">begin</span><span class="special">())</span></code>
              yielded before, if <code class="literal">p</code> was <code class="literal">position</code>'s
              parent
            </p></li><li class="listitem"><p>
              <code class="literal">position</code>'s parent's value is what <code class="literal">position</code>'s
              parent's parent's value yielded before. The ancestors of that cursor,
              and their structure, remain unchanged
            </p></li><li class="listitem"><p>
              <code class="computeroutput"><span class="special">(</span><span class="identifier">position</span><span class="special">.</span><span class="identifier">begin</span><span class="special">())[!</span><span class="identifier">par</span><span class="special">]</span></code>'s subtree is what <code class="computeroutput"><span class="special">(</span><span class="identifier">position</span><span class="special">.</span><span class="identifier">begin</span><span class="special">())[!</span><span class="identifier">par</span><span class="special">]</span></code>'s
              was before.
            </p></li><li class="listitem"><p>
              <code class="computeroutput"><span class="special">((</span><span class="identifier">position</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()[!</span><span class="identifier">par</span><span class="special">]).</span><span class="identifier">begin</span><span class="special">())\[</span><span class="identifier">par</span><span class="special">]</span></code>'s subtree is what <code class="computeroutput"><span class="special">(</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">begin</span><span class="special">())[!</span><span class="identifier">par</span><span class="special">]</span></code>'s
              was before, if <code class="literal">p</code> was <code class="literal">position</code>'s
              parent.
            </p></li><li class="listitem"><p>
              <code class="computeroutput"><span class="special">((</span><span class="identifier">position</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()[!</span><span class="identifier">par</span><span class="special">]).</span><span class="identifier">begin</span><span class="special">())[</span><span class="identifier">par</span><span class="special">]</span></code>'s subtree is what <code class="computeroutput"><span class="special">(</span><span class="identifier">position</span><span class="special">.</span><span class="identifier">begin</span><span class="special">())[!</span><span class="identifier">par</span><span class="special">]</span></code>'s
              was before.
            </p></li></ul></div></div><div class="simplesect std_specification" id="idp5475552"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Complexity:</em></span> constant
        </p></div><div class="simplesect std_specification" id="idp5476928"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Notes:</em></span> Does not affect the validity of cursors and
          references. Tree rotations are important inorder-preserving (see [order.iterators])
          operations on binary trees that are especially required by balancers.
        </p></div><div class="simplesect std_definition" id="idp5478544"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">clear</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5482896"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Notes:</em></span> Invalidates only the cursors and references
          to the erased elements.
        </p></div></div><div class="section" id="tree.tree.bintree.special"><div class="titlepage"><div><div><h6 class="title">23.7.4.1.6.&#160;<a class="link" href="#tree.tree.bintree.special" title="23.7.4.1.6.&#160;binary_tree specialized algorithms [bintree.special]"><code class="literal">binary_tree</code>
        specialized algorithms <span class="std_section_label">[bintree.special]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp5486672"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span>  <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
              <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5502384"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">y</span><span class="special">)</span></code>;
        </p></div></div></div><div class="section" id="tree.tree.narytree"><div class="titlepage"><div><div><h6 class="title">23.7.4.2.&#160;<a class="link" href="#tree.tree.narytree" title="23.7.4.2.&#160;Class template nary_tree [narytree]">Class template <code class="literal">nary_tree</code>
      <span class="std_section_label">[narytree]</span></a></h6></div></div></div><div class="section" id="tree.tree.narytree.synopsis"><div class="titlepage"><div><div><h6 class="title">23.7.4.2.1.&#160;<a class="link" href="#tree.tree.narytree.synopsis" title="23.7.4.2.1.&#160;nary_tree overview [narytree.overview]"><code class="literal">nary_tree</code>
        overview <span class="std_section_label">[narytree.overview]</span></a></h6></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span>
  <span class="keyword">class</span> <span class="identifier">nary_tree</span> <span class="special">{</span>
  <span class="keyword">public</span><span class="special">:</span>
    <span class="comment">// types:</span>
    <span class="keyword">typedef</span> <span class="identifier">value_type</span><span class="special">&amp;</span>                                   <span class="identifier">reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">&amp;</span>                             <span class="identifier">const_reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">cursor</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">const_cursor</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">size_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">difference_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">T</span>                                             <span class="identifier">value_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">Allocator</span>                                     <span class="identifier">allocator_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">allocator_traits</span><span class="special">&lt;</span><span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">pointer</span>              <span class="identifier">pointer</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">allocator_traits</span><span class="special">&lt;</span><span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">const_pointer</span>        <span class="identifier">const_pointer</span><span class="special">;</span>

    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">rebind</span> <span class="special">{</span>
      <span class="keyword">typedef</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Allocator</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">rebind</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">other</span> <span class="special">&gt;</span>
        <span class="identifier">other</span><span class="special">;</span>
    <span class="special">};</span>

    <span class="comment">// construct/copy/destroy:</span>
    <span class="keyword">explicit</span> <span class="identifier">nary_tree</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">Allocator</span><span class="special">());</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
      <span class="identifier">nary_tree</span> <span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">,</span>
        <span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">Allocator</span><span class="special">());</span>
    <span class="identifier">nary_tree</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&amp;);</span>
    <span class="identifier">nary_tree</span> <span class="special">(</span><span class="identifier">nary_tree</span><span class="special">&amp;&amp;);</span>
    <span class="identifier">nary_tree</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;);</span>
    <span class="identifier">nary_tree</span> <span class="special">(</span><span class="identifier">nary_tree</span><span class="special">&amp;&amp;,</span> <span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;);</span>
    <span class="special">~</span><span class="identifier">nary_tree</span><span class="special">();</span>
    <span class="identifier">nary_tree</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&amp;);</span>
    <span class="identifier">nary_tree</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">nary_tree</span><span class="special">&amp;&amp;);</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
    <span class="identifier">Allocator</span> <span class="identifier">get_allocator</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

    <span class="comment">// cursors:</span>
    <span class="identifier">cursor</span>        <span class="identifier">root</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">root</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">croot</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">cursor</span>        <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">cshoot</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

    <span class="comment">// capacity:</span>
    <span class="keyword">bool</span>      <span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">size_type</span> <span class="identifier">capacity</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="keyword">void</span>      <span class="identifier">reserve</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">shrink_to_fit</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>

    <span class="comment">// modifiers:</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;);</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
      <span class="identifier">cursor</span>  <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert_above</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert_above</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;);</span>
    <span class="keyword">void</span>      <span class="identifier">swap</span><span class="special">(</span><span class="identifier">nary_tree</span><span class="special">&amp;);</span>
    <span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">();</span>
  <span class="special">};</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span>  <span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span>  <span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

  <span class="comment">// specialized algorithms:</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span>  <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" id="tree.tree.narytree.types"><div class="titlepage"><div><div><h6 class="title">23.7.4.2.2.&#160;<a class="link" href="#tree.tree.narytree.types" title="23.7.4.2.2.&#160;nary_tree types [narytree.types]"><code class="literal">nary_tree</code>
        types <span class="std_section_label">[narytree.types]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp5744272"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">cursor</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">const_cursor</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp5749520"><div class="titlepage"></div><p>
          Both <code class="literal">cursor</code> and <code class="literal">const_cursor</code> have
          to fulfill the plain cursor ([cursor.flavors]) and ascending random access
          cursor ([ascending.random.access.cursors]) requirements.
        </p></div></div><div class="section" id="tree.tree.narytree.cons"><div class="titlepage"><div><div><h6 class="title">23.7.4.2.3.&#160;<a class="link" href="#tree.tree.narytree.cons" title="23.7.4.2.3.&#160;nary_tree constructors, copy, and assignment [narytree.cons]"><code class="literal">nary_tree</code>
        constructors, copy, and assignment <span class="std_section_label">[narytree.cons]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp5754208"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">nary_tree</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">Allocator</span><span class="special">());</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="identifier">nary_tree</span> <span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">,</span>
    <span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">Allocator</span><span class="special">());</span>
<span class="identifier">nary_tree</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">nary_tree</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5773216"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Complexity:</em></span> The constructor <code class="computeroutput"><span class="keyword">template</span>
          <span class="special">&lt;</span><span class="keyword">class</span>
          <span class="identifier">InputCursor</span><span class="special">&gt;</span>
          <span class="identifier">nary_tree</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">)</span></code> makes only <code class="literal">N</code> calls
          to the copy constructor of <code class="literal">T</code> (where <code class="literal">N</code>
          is the number of elements in <code class="literal">subtree</code>) and no reallocations
          if the cursor <code class="literal">subtree</code> is of (either descending or ascending)
          forward, bidirectional, or random access categories. It does at most <code class="literal">2N</code>
          calls to the copy constructor of <code class="literal">T</code> and <code class="literal">logN</code>
          reallocations if they are just cursors, since it is impossible to determine
          the size of <code class="literal">subtree</code> and then do copying.
        </p></div><div class="simplesect std_definition" id="idp5786096"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5793232"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Effects:</em></span>
        </p><pre class="programlisting"><span class="identifier">clear</span><span class="special">();</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">auto</span> <span class="identifier">v</span> <span class="special">:</span> <span class="identifier">subtree</span><span class="special">)</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">root</span><span class="special">().</span><span class="identifier">end</span><span class="special">(),</span> <span class="special">*</span><span class="identifier">i</span><span class="special">);</span>
</pre></div></div><div class="section" id="tree.tree.narytree.cursors"><div class="titlepage"><div><div><h6 class="title">23.7.4.2.4.&#160;<a class="link" href="#tree.tree.narytree.cursors" title="23.7.4.2.4.&#160;nary_tree cursors [narytree.cursors]"><code class="literal">nary_tree</code>
        cursors <span class="std_section_label">[narytree.cursors]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp5806928"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">cursor</span>        <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">const_cursor</span>  <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
<span class="identifier">const_cursor</span>  <span class="identifier">cshoot</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp5817584"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Complexity:</em></span> constant
        </p></div></div><div class="section" id="tree.tree.narytree.capacity"><div class="titlepage"><div><div><h6 class="title">23.7.4.2.5.&#160;<a class="link" href="#tree.tree.narytree.capacity" title="23.7.4.2.5.&#160;nary_tree capacity [narytree.capacity]"><code class="literal">nary_tree</code>
        capacity <span class="std_section_label">[narytree.capacity]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp5821264"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">size_type</span> <span class="identifier">capacity</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp5827312"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Returns:</em></span> The total number of child elements that the
          cursor <code class="literal">position</code> can hold without requiring reallocation.
        </p></div><div class="simplesect std_definition" id="idp5829424"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">reserve</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5835472"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Effects:</em></span> A directive that informs an <code class="literal">nary_tree</code>
          of a planned change in a given cursor's size, so that it can manage the
          storage allocation accordingly. After <code class="computeroutput"><span class="identifier">reserve</span><span class="special">(</span><span class="identifier">position</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span></code>,
          <code class="computeroutput"><span class="identifier">capacity</span><span class="special">(</span><span class="identifier">position</span><span class="special">)</span></code>
          is greater or equal to the <code class="literal">size_type</code> argument <code class="literal">n</code>
          of reserve if reallocation happens; and equal to the previous value of
          <code class="computeroutput"><span class="identifier">capacity</span><span class="special">(</span><span class="identifier">position</span><span class="special">)</span></code>
          otherwise. Reallocation happens at this point if and only if the current
          capacity is less than the <code class="literal">size_type</code> argument <code class="literal">n</code>
          of <code class="computeroutput"><span class="identifier">reserve</span><span class="special">()</span></code>.
        </p></div><div class="simplesect std_specification" id="idp5849984"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Complexity:</em></span> It does not change the size of the <code class="literal">nary_tree</code>
          and takes at most linear time in <code class="computeroutput"><span class="identifier">position</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span></code>.
        </p></div><div class="simplesect std_specification" id="idp5854368"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Notes:</em></span> Reallocation invalidates all the references,
          pointers, and cursors referring to the child elements of <code class="literal">position</code>.
          It is guaranteed that no reallocation takes place during insertions to
          <code class="literal">position</code> that happen after a call to <code class="computeroutput"><span class="identifier">reserve</span><span class="special">()</span></code> until the time when an insertion would
          make <code class="computeroutput"><span class="identifier">position</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span></code>
          greater than the size specified in the most recent call to <code class="computeroutput"><span class="identifier">reserve</span><span class="special">()</span></code>.
        </p></div></div><div class="section" id="tree.tree.narytree.modifiers"><div class="titlepage"><div><div><h6 class="title">23.7.4.2.6.&#160;<a class="link" href="#tree.tree.narytree.modifiers" title="23.7.4.2.6.&#160;nary_tree modifiers [narytree.modifiers]"><code class="literal">nary_tree</code>
        modifiers <span class="std_section_label">[narytree.modifiers]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp5864912"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
<span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="identifier">cursor</span>  <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
<span class="identifier">cursor</span>    <span class="identifier">insert_above</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
<span class="identifier">cursor</span>    <span class="identifier">insert_above</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;);</span>
</pre></div><div class="simplesect std_specification" id="idp5892368"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Notes:</em></span> Does not affect the validity of cursors and
          references.
        </p></div><div class="simplesect std_definition" id="idp5893824"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">clear</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5898176"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Notes:</em></span> Invalidates only the cursors and references
          to the erased elements.
        </p></div></div><div class="section" id="tree.tree.narytree.special"><div class="titlepage"><div><div><h6 class="title">23.7.4.2.7.&#160;<a class="link" href="#tree.tree.narytree.special" title="23.7.4.2.7.&#160;nary_tree specialized algorithms [narytree.special]"><code class="literal">nary_tree</code>
        specialized algorithms <span class="std_section_label">[narytree.special]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp5901952"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span>  <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
              <span class="identifier">nary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp5917664"><div class="titlepage"></div><p>
          <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">y</span><span class="special">);</span></code>
        </p></div></div></div><div class="section" id="tree.tree.adaptors"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.&#160;<a class="link" href="#tree.tree.adaptors" title="23.7.4.3.&#160;Hierarchy adaptors [hierarchy.adaptors]">Hierarchy adaptors <span class="std_section_label">[hierarchy.adaptors]</span></a></h6></div></div></div><div class="section" id="tree.tree.adaptors.general"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.1.&#160;<a class="link" href="#tree.tree.adaptors.general" title="23.7.4.3.1.&#160;In general [hiearchy.adaptors.general]">In general <span class="std_section_label">[hiearchy.adaptors.general]</span></a></h6></div></div></div><p>
          Hierarchy adaptors each take a <code class="literal">Hierarchy</code> template parameter,
          and each of their constructors takes a <code class="literal">Hierarchy</code> reference
          argument. This hierarchy is copied into the <code class="literal">Hierarchy</code>
          member of each adapter. Most hierarchy adaptors satisfy most of the hierarchy
          requirements (except for anything that deals with allocators, as storage
          management is done by the adaptees). The exception is the group of balancing
          hierarchy adaptors ([hierarchy.balance]), whose members satisfy most of
          the requirements of a container, of a sequence and most of the optional
          sequence requirements instead (again except for anything allocation related,
          and some other exceptions).
        </p><div class="simplesect std_paragraph" id="idp5928976"><div class="titlepage"></div><p>
          Headers <code class="literal">&lt;forest_tree&gt;</code>, and <code class="literal">&lt;multiway_tree&gt;</code>
          define template classes that meet the requirements for hierarchies.
        </p><p>
          <span class="bold"><strong>Header <code class="literal">forest_tree</code> synopsis</strong></span>
        </p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">forest_tree</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
          <span class="bold"><strong>Header <code class="literal">multiway_tree</code> synopsis</strong></span>
        </p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
    <span class="keyword">class</span> <span class="identifier">multiway_tree</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span>
      <span class="keyword">const</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span>
      <span class="keyword">const</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div></div><div class="section" id="tree.tree.adaptors.foresttree"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.2.&#160;<a class="link" href="#tree.tree.adaptors.foresttree" title="23.7.4.3.2.&#160;Class template forest_tree [foresttree]">Class template <code class="literal">forest_tree</code>
        <span class="std_section_label">[foresttree]</span></a></h6></div></div></div><div class="section" id="tree.tree.adaptors.foresttree.defn"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.2.1.&#160;<a class="link" href="#tree.tree.adaptors.foresttree.defn" title="23.7.4.3.2.1.&#160;forest_tree definition [foresttree.defn]"><code class="literal">forest_tree</code>
          definition <span class="std_section_label">[foresttree.defn]</span></a></h6></div></div></div><div class="simplesect std_paragraph" id="idp6045744"><div class="titlepage"></div><p>
            A <code class="literal">forest_tree</code> is a kind of mutable plain hierarchy
            that is instantiated with a mutable multiway hierarchy that has insertion
            semantics as a <code class="literal">binary_tree</code> ([bintree.modifiers])),
            and whose cursor types <code class="literal">cursor</code> and <code class="literal">const_cursor</code>
            satisfy a <code class="literal">binary_tree</code>'s <code class="literal">cursor</code>
            and <code class="literal">const_cursor</code> type requirements ([bintree.types])).
          </p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span>
  <span class="keyword">class</span> <span class="identifier">forest_tree</span> <span class="special">{</span>
  <span class="keyword">public</span><span class="special">:</span>
    <span class="keyword">typedef</span> <span class="identifier">Hierarchy</span>                                     <span class="identifier">hierarchy_type</span><span class="special">;</span>

  <span class="keyword">protected</span><span class="special">:</span>
    <span class="identifier">Hierarchy</span> <span class="identifier">h</span><span class="special">;</span>

  <span class="keyword">public</span><span class="special">:</span>
    <span class="comment">// types:</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">reference</span>                 <span class="identifier">reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_reference</span>           <span class="identifier">const_reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">cursor</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">const_cursor</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">size_type</span>                 <span class="identifier">size_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">difference_type</span>           <span class="identifier">difference_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">T</span>                                             <span class="identifier">value_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">pointer</span>                   <span class="identifier">pointer</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_pointer</span>             <span class="identifier">const_pointer</span><span class="special">;</span>

    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">rebind</span> <span class="special">{</span>
      <span class="keyword">typedef</span> <span class="identifier">forest_tree</span><span class="special">&lt;</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">rebind</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">other</span> <span class="special">&gt;</span>
        <span class="identifier">other</span><span class="special">;</span>
    <span class="special">};</span>

    <span class="comment">// construct/copy/destroy:</span>
    <span class="keyword">explicit</span> <span class="identifier">forest_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Hierarchy</span><span class="special">&amp;);</span>
    <span class="keyword">explicit</span> <span class="identifier">forest_tree</span><span class="special">(</span><span class="identifier">Hierarchy</span><span class="special">&amp;&amp;</span> <span class="special">=</span> <span class="identifier">Hierarchy</span><span class="special">());</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
      <span class="identifier">forest_tree</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
    <span class="identifier">forest_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">forest_tree</span><span class="special">&amp;);</span>
    <span class="identifier">forest_tree</span><span class="special">(</span><span class="identifier">forest_tree</span><span class="special">&amp;&amp;);</span>
    <span class="identifier">forest_tree</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">forest_tree</span><span class="special">&amp;);</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
      <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>

    <span class="comment">// cursors:</span>
    <span class="identifier">cursor</span>        <span class="identifier">root</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">h</span><span class="special">.</span><span class="identifier">root</span><span class="special">();</span> <span class="special">}</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">root</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">h</span><span class="special">.</span><span class="identifier">root</span><span class="special">();</span> <span class="special">}</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">croot</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">h</span><span class="special">.</span><span class="identifier">croot</span><span class="special">();</span> <span class="special">}</span>
    <span class="identifier">cursor</span>        <span class="identifier">shoot</span><span class="special">();</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">cshoot</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>

    <span class="comment">// capacity:</span>
    <span class="keyword">bool</span>      <span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">h</span><span class="special">.</span><span class="identifier">empty</span><span class="special">();</span> <span class="special">}</span>
    <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span>  <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">h</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">}</span>
    <span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>

    <span class="comment">// modifiers:</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">&amp;);</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">value_type</span><span class="special">&amp;&amp;);</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
      <span class="identifier">cursor</span>  <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert_above</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">&amp;);</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert_above</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">value_type</span><span class="special">&amp;&amp;);</span>
    <span class="keyword">void</span>      <span class="identifier">swap</span><span class="special">(</span><span class="identifier">forest_tree</span><span class="special">&amp;);</span>
    <span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">();</span>
  <span class="special">};</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span>  <span class="keyword">const</span> <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span>  <span class="keyword">const</span> <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

  <span class="comment">// specialized algorithms:</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span>  <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div></div><div class="section" id="tree.tree.adaptors.foresttree.types"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.2.2.&#160;<a class="link" href="#tree.tree.adaptors.foresttree.types" title="23.7.4.3.2.2.&#160;forest_tree types [foresttree.types]"><code class="literal">forest_tree</code>
          types <span class="std_section_label">[foresttree.types]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp6286224"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">cursor</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">const_cursor</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp6291472"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Notes:</em></span> If (the adaptee) <code class="literal">Hierarchy</code>'s
            cursor types are at least ascending bidirectional cursors, both <code class="literal">cursor</code>
            and <code class="literal">const_cursor</code> are ascending bidirectional cursors.
            Otherwise, they are descending forward cursors. The adaptee binary tree
            is "tilted" to yield an n-ary tree, meaning that the operational
            semantics of the adaptor cursor are as follows in terms of the adaptee
            cursor (only valid if present in the adaptor cursor's category; only
            given for mutable versions of expressions, const ones as according; expressions
            missing from the list mean operational semantics and complexity are for
            <code class="literal">b</code> as they are for <code class="literal">f</code>):
          </p><div class="table" id="tree.tree.adaptors.foresttree.types.table6"><div class="table-title">Table&#160;6.&#160;forest_tree/binary tree cursor operational semantics correspondences</div><div class="table-contents"><table class="table" summary="forest_tree/binary tree cursor operational semantics correspondences"><colgroup><col><col><col></colgroup><thead><tr><th>
                    <p>
                      adaptor cursor <code class="literal">f</code>
                    </p>
                  </th><th>
                    <p>
                      adaptee cursor <code class="literal">b</code>
                    </p>
                  </th><th>
                    <p>
                      complexity
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">f</span> <span class="special">=</span>
                      <span class="identifier">f</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">while</span> <span class="special">(!</span><span class="identifier">b</span><span class="special">.</span><span class="identifier">empty</span><span class="special">())</span>
                      <span class="identifier">b</span> <span class="special">=</span>
                      <span class="identifier">b</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span></code>
                    </p>
                  </td><td>
                    <p>
                      linear
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="special">++</span><span class="identifier">f</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">b</span> <span class="special">=</span>
                      <span class="special">(++</span><span class="identifier">b</span><span class="special">).</span><span class="identifier">begin</span><span class="special">();</span></code>
                    </p>
                  </td><td>
                    <p>
                      constant
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="special">--</span><span class="identifier">f</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="identifier">b</span> <span class="special">=</span>
                      <span class="special">--</span><span class="identifier">b</span><span class="special">.</span><span class="identifier">parent</span><span class="special">();</span></code>
                    </p>
                  </td><td>
                    <p>
                      as <code class="computeroutput"><span class="identifier">b</span><span class="special">.</span><span class="identifier">parent</span><span class="special">()</span></code>
                    </p>
                  </td></tr><tr><td>
                    <p>
                      <code class="computeroutput"><span class="special">!</span><span class="identifier">f</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="keyword">while</span> <span class="special">((!</span><span class="identifier">b</span><span class="special">).</span><span class="identifier">parity</span><span class="special">()</span>
                      <span class="special">==</span> <span class="number">1</span><span class="special">);</span> <span class="identifier">b</span>
                      <span class="special">=</span> <span class="special">(!</span><span class="identifier">b</span><span class="special">).</span><span class="identifier">begin</span><span class="special">();</span></code>
                    </p>
                  </td><td>
                    <p>
                      linear
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"></div></div><div class="section" id="tree.tree.adaptors.foresttree.cons"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.2.3.&#160;<a class="link" href="#tree.tree.adaptors.foresttree.cons" title="23.7.4.3.2.3.&#160;forest_tree constructors, copy, and assignment [foresttree.cons]"><code class="literal">forest_tree</code>
          constructors, copy, and assignment <span class="std_section_label">[foresttree.cons]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp6350624"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="identifier">forest_tree</span> <span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
<span class="identifier">forest_tree</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">forest_tree</span><span class="special">&amp;);</span>
</pre></div><div class="simplesect std_specification" id="idp6360064"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Complexity:</em></span> The constructor <code class="computeroutput"><span class="keyword">template</span>
            <span class="special">&lt;</span><span class="keyword">class</span>
            <span class="identifier">InputCursor</span><span class="special">&gt;</span>
            <span class="identifier">forest_tree</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">)</span></code> makes only <code class="literal">N</code> calls
            to the copy constructor of <code class="literal">T</code> (where <code class="literal">N</code>
            is the number of elements in <code class="literal">subtree</code>) and no reallocations
            if the cursor <code class="literal">subtree</code> is of (either descending or
            ascending) forward, bidirectional, or random access categories. It does
            at most <code class="literal">2N</code> calls to the copy constructor of <code class="literal">T</code>
            and <code class="literal">logN</code> reallocations if they are just cursors, since
            it is impossible to determine the size of <code class="literal">subtree</code>
            and then do copying.
          </p></div><div class="simplesect std_definition" id="idp6373024"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp6380160"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Effects:</em></span>
          </p><pre class="programlisting"><span class="identifier">clear</span><span class="special">();</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">auto</span> <span class="identifier">v</span> <span class="special">:</span> <span class="identifier">subtree</span><span class="special">)</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">root</span><span class="special">().</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">v</span><span class="special">);</span>
</pre></div></div><div class="section" id="tree.tree.adaptors.foresttree.cursors"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.2.4.&#160;<a class="link" href="#tree.tree.adaptors.foresttree.cursors" title="23.7.4.3.2.4.&#160;forest_tree cursors [foresttree.cursors]"><code class="literal">forest_tree</code>
          cursors <span class="std_section_label">[foresttree.cursors]</span></a></h6></div></div></div></div><div class="section" id="tree.tree.adaptors.foresttree.modifiers"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.2.5.&#160;<a class="link" href="#tree.tree.adaptors.foresttree.modifiers" title="23.7.4.3.2.5.&#160;forest_tree modifiers [foresttree.modifiers]"><code class="literal">forest_tree</code>
          modifiers <span class="std_section_label">[foresttree.modifiers]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp6395680"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">value_type</span><span class="special">&amp;&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="identifier">cursor</span>  <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
<span class="identifier">cursor</span>    <span class="identifier">insert_above</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
<span class="identifier">cursor</span>    <span class="identifier">insert_above</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">value_type</span><span class="special">&amp;&amp;</span> <span class="identifier">x</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp6427488"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Notes:</em></span> Does not affect the validity of cursors and
            references.
          </p></div><div class="simplesect std_definition" id="idp6428944"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp6433296"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Notes:</em></span> Invalidates only the cursors and references
            to the erased elements.
          </p></div></div><div class="section" id="tree.tree.adaptors.foresttree.special"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.2.6.&#160;<a class="link" href="#tree.tree.adaptors.foresttree.special" title="23.7.4.3.2.6.&#160;forest_tree specialized algorithms [foresttree.special]"><code class="literal">forest_tree</code>
          specialized algorithms <span class="std_section_label">[foresttree.special]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp6437072"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span>  <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
            <span class="identifier">forest_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp6452784"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">y</span><span class="special">);</span></code>
          </p></div></div></div><div class="section" id="tree.tree.adaptors.multiwaytree"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.3.&#160;<a class="link" href="#tree.tree.adaptors.multiwaytree" title="23.7.4.3.3.&#160;Template class multiway_tree [multiwaytree]">Template class <code class="literal">multiway_tree</code>
        <span class="std_section_label">[multiwaytree]</span></a></h6></div></div></div><div class="section" id="tree.tree.adaptors.multiwaytree.defn"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.3.1.&#160;<a class="link" href="#tree.tree.adaptors.multiwaytree.defn" title="23.7.4.3.3.1.&#160;multiway_tree definition [multiwaytree.defn]"><code class="literal">multiway_tree</code>
          definition <span class="std_section_label">[multiwaytree.defn]</span></a></h6></div></div></div><div class="simplesect std_paragraph" id="idp6462256"><div class="titlepage"></div><p>
            A <code class="literal">multiway_tree</code> is a kind of mutable multiway hierarchy
            that is instantiated with a mutable plain hierarchy whose value type
            in turn is a container holding elements of <code class="literal">multiway_tree</code>'s
            <code class="literal">value_type</code>.
          </p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">nary_tree</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
  <span class="keyword">class</span> <span class="identifier">multiway_tree</span>
  <span class="special">{</span>
  <span class="keyword">public</span><span class="special">:</span>
    <span class="keyword">typedef</span> <span class="identifier">Hierarchy</span>                                     <span class="identifier">hierarchy_type</span><span class="special">;</span>

  <span class="keyword">protected</span><span class="special">:</span>
    <span class="identifier">Hierachy</span> <span class="identifier">h</span><span class="special">;</span>

  <span class="keyword">public</span><span class="special">:</span>
    <span class="comment">// types:</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierachy</span><span class="special">::</span><span class="identifier">reference</span>                  <span class="identifier">reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierachy</span><span class="special">::</span><span class="identifier">const_reference</span>            <span class="identifier">const_reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">cursor</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">const_cursor</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierachy</span><span class="special">::</span><span class="identifier">size_type</span>                  <span class="identifier">size_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierachy</span><span class="special">::</span><span class="identifier">difference_type</span>            <span class="identifier">difference_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">T</span>                                             <span class="identifier">value_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierachy</span><span class="special">::</span><span class="identifier">pointer</span>                    <span class="identifier">pointer</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Hierachy</span><span class="special">::</span><span class="identifier">const_pointer</span>              <span class="identifier">const_pointer</span><span class="special">;</span>

    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">rebind</span> <span class="special">{</span>
      <span class="keyword">typedef</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span> <span class="identifier">U</span><span class="special">,</span>
        <span class="keyword">typename</span> <span class="identifier">Hierachy</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">rebind</span><span class="special">&lt;</span> <span class="identifier">implementation</span> <span class="identifier">defined</span> <span class="special">&gt;::</span><span class="identifier">other</span> <span class="special">&gt;</span>
          <span class="identifier">other</span><span class="special">;</span>
    <span class="special">};</span>

    <span class="comment">// construct/copy/destroy:</span>
    <span class="keyword">explicit</span> <span class="identifier">multiway_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Hierachy</span><span class="special">&amp;);</span>
    <span class="keyword">explicit</span> <span class="identifier">multiway_tree</span><span class="special">(</span><span class="identifier">Hierachy</span><span class="special">&amp;&amp;</span> <span class="special">=</span> <span class="identifier">Hierachy</span><span class="special">());</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
      <span class="identifier">multiway_tree</span> <span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
    <span class="identifier">multiway_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">multiway_tree</span><span class="special">&amp;);</span>
    <span class="identifier">multiway_tree</span><span class="special">(</span><span class="identifier">multiway_tree</span><span class="special">&amp;&amp;)</span>
    <span class="special">~</span><span class="identifier">multiway_tree</span><span class="special">();</span>
    <span class="identifier">multiway_tree</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">multiway_tree</span><span class="special">&amp;);</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
      <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>

    <span class="comment">// cursors:</span>
    <span class="identifier">cursor</span>        <span class="identifier">root</span><span class="special">();</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">root</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">croot</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="identifier">cursor</span>        <span class="identifier">shoot</span><span class="special">();</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">cshoot</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>

    <span class="comment">// capacity:</span>
    <span class="keyword">bool</span>      <span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="identifier">size_type</span> <span class="identifier">capacity</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="keyword">void</span>      <span class="identifier">reserve</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>

    <span class="comment">// modifiers:</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">&amp;);</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">value_type</span><span class="special">&amp;&amp;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">value_type</span><span class="special">());</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
      <span class="identifier">cursor</span>  <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">rotate</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">swap</span><span class="special">(</span><span class="identifier">multiway_tree</span><span class="special">&amp;);</span>
    <span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">();</span>
  <span class="special">};</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span>  <span class="keyword">const</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span>  <span class="keyword">const</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                      <span class="keyword">const</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

  <span class="comment">// specialized algorithms:</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span>  <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
                <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><p>
            Types <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">cursor</span></code>
            and <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span></code>
            are required to be random access cursors.
          </p></div><div class="section" id="tree.tree.adaptors.multiwaytree.types"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.3.2.&#160;<a class="link" href="#tree.tree.adaptors.multiwaytree.types" title="23.7.4.3.3.2.&#160;multiway_tree types [multiwaytree.types]"><code class="literal">multiway_tree</code>
          types <span class="std_section_label">[multiwaytree.types]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp6682688"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">cursor</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">const_cursor</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp6687936"><div class="titlepage"></div><p>
            Both <code class="literal">cursor</code> and <code class="literal">const_cursor</code> have
            to fulfill the plain cursor requirements ([cursor.flavors]). If <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">cursor</span></code>
            is an ascending random access cursor, <code class="literal">cursor</code> and
            <code class="literal">const_cursor</code> are also ascending random access cursors
            ([ascending.random.access.cursors]); otherwise, they are descending random
            access cursor ([descending.random.access.cursors]).
          </p></div><div class="simplesect std_specification" id="idp6694256"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Notes:</em></span> The operational semantics of the adaptor
            cursor are as follows in terms of the adaptee cursor (only valid if present
            in the adaptor cursor's category; only given for mutable versions of
            expressions, const ones as according; expressions missing from the list
            mean operational semantics and complexity are for <code class="literal">m</code>
            as they are for <code class="literal">n</code>):
          </p><div class="table" id="tree.tree.adaptors.multiwaytree.types.table7"><div class="table-title">Table&#160;7.&#160;Multiway/nary tree cursor operational semantics correspondences</div><div class="table-contents"><table class="table" summary="Multiway/nary tree cursor operational semantics correspondences"><colgroup><col><col><col></colgroup><thead><tr><th>
                    <p>
                      adaptor cursor <code class="literal">m</code>
                    </p>
                  </th><th>
                    <p>
                      adaptee cursor <code class="literal">n</code>
                    </p>
                  </th><th>
                    <p>
                      complexity
                    </p>
                  </th></tr></thead><tbody><tr><td>
                    <p>
                      <code class="computeroutput"><span class="special">*</span><span class="identifier">m</span></code>
                    </p>
                  </td><td>
                    <p>
                      <code class="computeroutput"><span class="special">*((</span><span class="identifier">p</span><span class="special">-&gt;</span><span class="identifier">begin</span><span class="special">())[</span><span class="identifier">b</span><span class="special">.</span><span class="identifier">parity</span><span class="special">()])</span></code>
                    </p>
                  </td><td>
                    <p>
                      constant
                    </p>
                  </td></tr></tbody></table></div></div><br class="table-break"></div></div><div class="section" id="tree.tree.adaptors.multiwaytree.cons"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.3.3.&#160;<a class="link" href="#tree.tree.adaptors.multiwaytree.cons" title="23.7.4.3.3.3.&#160;multiway_tree constructors, copy, and assignment [multiwaytree.cons]"><code class="literal">multiway_tree</code>
          constructors, copy, and assignment <span class="std_section_label">[multiwaytree.cons]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp6715136"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">multiway_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Hierachy</span><span class="special">&amp;);</span>
<span class="keyword">explicit</span> <span class="identifier">multiway_tree</span><span class="special">(</span><span class="identifier">Hierachy</span><span class="special">&amp;&amp;</span> <span class="special">=</span> <span class="identifier">Hierachy</span><span class="special">());</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="identifier">multiway_tree</span> <span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
<span class="identifier">multiway_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">multiway_tree</span><span class="special">&amp;);</span>
<span class="identifier">multiway_tree</span><span class="special">(</span><span class="identifier">multiway_tree</span><span class="special">&amp;&amp;)</span>
</pre></div><div class="simplesect std_specification" id="idp6734112"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Complexity:</em></span> The constructor <code class="computeroutput"><span class="keyword">template</span>
            <span class="special">&lt;</span><span class="keyword">class</span>
            <span class="identifier">InputCursor</span><span class="special">&gt;</span>
            <span class="identifier">multiway_tree</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">)</span></code> makes only <code class="literal">N</code> calls
            to the copy constructor of <code class="literal">T</code> (where <code class="literal">N</code>
            is the number of elements in <code class="literal">subtree</code>) and no reallocations
            if the cursor <code class="literal">subtree</code> is of (either descending or
            ascending) forward, bidirectional, or random access categories. It does
            at most <code class="literal">2N</code> calls to the copy constructor of <code class="literal">T</code>
            and <code class="literal">logN</code> reallocations if they are just cursors, since
            it is impossible to determine the size of <code class="literal">subtree</code>
            and then do copying.
          </p></div><div class="simplesect std_definition" id="idp6747072"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp6754208"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Effects:</em></span>
          </p><pre class="programlisting"><span class="identifier">clear</span><span class="special">();</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">auto</span> <span class="identifier">v</span> <span class="special">:</span> <span class="identifier">subtree</span><span class="special">)</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">root</span><span class="special">().</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">v</span><span class="special">);</span>
</pre></div></div><div class="section" id="tree.tree.adaptors.multiwaytree.cursors"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.3.4.&#160;<a class="link" href="#tree.tree.adaptors.multiwaytree.cursors" title="23.7.4.3.3.4.&#160;multiway_tree cursors [multiwaytree.cursors]"><code class="literal">multiway_tree</code>
          cursors <span class="std_section_label">[multiwaytree.cursors]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp6767424"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">cursor</span>        <span class="identifier">shoot</span><span class="special">();</span>
<span class="identifier">const_cursor</span>  <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
<span class="identifier">const_cursor</span>  <span class="identifier">cshoot</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp6775776"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Complexity:</em></span> constant
          </p></div></div><div class="section" id="tree.tree.adaptors.multiwaytree.capacity"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.3.5.&#160;<a class="link" href="#tree.tree.adaptors.multiwaytree.capacity" title="23.7.4.3.3.5.&#160;multiway_tree capacity [multiwaytree.capacity]"><code class="literal">multiway_tree</code>
          capacity <span class="std_section_label">[multiwaytree.capacity]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp6779456"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">size_type</span> <span class="identifier">capacity</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp6784896"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Returns:</em></span> The total number of child elements that
            the cursor <code class="literal">position</code> can hold without requiring reallocation.
          </p></div><div class="simplesect std_definition" id="idp6787024"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">reserve</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp6793072"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Effects:</em></span> A directive that informs an <code class="literal">multiway_tree</code>
            of a planned change in a given cursor's size, so that it can manage the
            storage allocation accordingly. After <code class="computeroutput"><span class="identifier">reserve</span><span class="special">(</span><span class="identifier">position</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span></code>, <code class="computeroutput"><span class="identifier">capacity</span><span class="special">(</span><span class="identifier">position</span><span class="special">)</span></code> is greater or equal to the <code class="literal">size_type</code>
            argument <code class="literal">n</code> of reserve if reallocation happens; and
            equal to the previous value of <code class="computeroutput"><span class="identifier">capacity</span><span class="special">(</span><span class="identifier">position</span><span class="special">)</span></code> otherwise. Reallocation happens at this
            point if and only if the current capacity is less than the <code class="literal">size_type</code>
            argument <code class="literal">n</code> of <code class="computeroutput"><span class="identifier">reserve</span><span class="special">()</span></code>.
          </p></div><div class="simplesect std_specification" id="idp6807584"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Complexity:</em></span> It does not change the size of the
            <code class="literal">multiway_tree</code> and takes at most linear time in <code class="computeroutput"><span class="identifier">position</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span></code>.
          </p></div><div class="simplesect std_specification" id="idp6812032"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Notes:</em></span> Reallocation invalidates all the references,
            pointers, and cursors referring to the child elements of <code class="literal">position</code>.
            It is guaranteed that no reallocation takes place during insertions to
            <code class="literal">position</code> that happen after a call to <code class="computeroutput"><span class="identifier">reserve</span><span class="special">()</span></code>
            until the time when an insertion would make <code class="computeroutput"><span class="identifier">position</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span></code> greater than the size specified in
            the most recent call to <code class="computeroutput"><span class="identifier">reserve</span><span class="special">()</span></code>.
          </p></div></div><div class="section" id="tree.tree.adaptors.multiwaytree.modifiers"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.3.6.&#160;<a class="link" href="#tree.tree.adaptors.multiwaytree.modifiers" title="23.7.4.3.3.6.&#160;multiway_tree modifiers [multiwaytree.modifiers]"><code class="literal">multiway_tree</code>
          modifiers <span class="std_section_label">[multiwaytree.modifiers]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp6822592"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span><span class="special">&amp;);</span>
<span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">value_type</span><span class="special">&amp;&amp;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">value_type</span><span class="special">());</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
  <span class="identifier">cursor</span>  <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp6843040"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Notes:</em></span> Does not affect the validity of cursors and
            references.
          </p></div><div class="simplesect std_definition" id="idp6844496"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp6848848"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Notes:</em></span> Invalidates only the cursors and references
            to the erased elements.
          </p></div></div><div class="section" id="tree.tree.adaptors.multiwaytree.special"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.3.7.&#160;<a class="link" href="#tree.tree.adaptors.multiwaytree.special" title="23.7.4.3.3.7.&#160;multiway_tree specialized algorithms [multiwaytree.special]"><code class="literal">multiway_tree</code>
          specialized algorithms <span class="std_section_label">[multiwaytree.special]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp6852624"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span>  <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
              <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp6868336"><div class="titlepage"></div><p>
            <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">y</span><span class="special">);</span></code>
          </p></div></div></div><div class="section" id="tree.tree.adaptors.augment"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.4.&#160;<a class="link" href="#tree.tree.adaptors.augment" title="23.7.4.3.4.&#160;Augmenting hierarchy adaptors [hierarchy.augment]">Augmenting hierarchy adaptors
        <span class="std_section_label">[hierarchy.augment]</span></a></h6></div></div></div><div class="section" id="tree.tree.adaptors.augment.general"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.4.1.&#160;<a class="link" href="#tree.tree.adaptors.augment.general" title="23.7.4.3.4.1.&#160;In general [hierarchy.augment.general]">In general <span class="std_section_label">[hierarchy.augment.general]</span></a></h6></div></div></div><p>
            An augmenting hierarchy "augments" a mutable multiway hierarchy
            which it is given as a template parameter by associating additional information
            with its elements and modeling a mutable multiway hierarchy in turn.
            This additional information is not directly exposed, but only readable
            via certain member functions of the augmentor; it is updated internally
            in order to adapt to structural or content-wise changes in the hierarchy.
            The library provides one augmenting hierarchy adaptor template class:
            <code class="literal">rank_tree</code>, found in header <code class="literal">&lt;rank_tree&gt;</code>.
          </p><p>
            <span class="bold"><strong>Header <code class="literal">&lt;rank_tree&gt;</code> synopsis</strong></span>
          </p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">initializer_list</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">rank_tree</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" id="tree.tree.adaptors.augment.ranktree"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.4.2.&#160;<a class="link" href="#tree.tree.adaptors.augment.ranktree" title="23.7.4.3.4.2.&#160;Class template rank_tree [ranktree]">Class template
          <code class="literal">rank_tree</code> <span class="std_section_label">[ranktree]</span></a></h6></div></div></div><div class="section" id="tree.tree.adaptors.augment.ranktree.defn"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.4.2.1.&#160;<a class="link" href="#tree.tree.adaptors.augment.ranktree.defn" title="23.7.4.3.4.2.1.&#160;rank_tree definition [ranktree.defn]"><code class="literal">rank_tree</code>
            definition <span class="std_section_label">[ranktree.defn]</span></a></h6></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span>
  <span class="keyword">class</span> <span class="identifier">rank_tree</span>
  <span class="special">{</span>
  <span class="keyword">public</span><span class="special">:</span>
    <span class="keyword">typedef</span> <span class="identifier">Hierarchy</span>                                     <span class="identifier">hierarchy_type</span><span class="special">;</span>

  <span class="keyword">protected</span><span class="special">:</span>
    <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">rebind</span><span class="special">&lt;</span> <span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">size_t</span><span class="special">&gt;</span> <span class="special">&gt;::</span><span class="identifier">other</span>
      <span class="identifier">rank_tree_type</span><span class="special">;</span>

  <span class="keyword">public</span><span class="special">:</span>
    <span class="comment">// types:</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">reference</span>            <span class="identifier">reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">const_reference</span>      <span class="identifier">const_reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">cursor</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">const_cursor</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">size_type</span>            <span class="identifier">size_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">difference_type</span>      <span class="identifier">difference_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">T</span>                                             <span class="identifier">value_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">pointer</span>              <span class="identifier">pointer</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">const_pointer</span>        <span class="identifier">const_pointer</span><span class="special">;</span>

    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">rebind</span> <span class="special">{</span>
      <span class="keyword">typedef</span> <span class="identifier">rank_tree</span><span class="special">&lt;</span> <span class="identifier">U</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="keyword">template</span> <span class="identifier">rebind</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;::</span><span class="identifier">other</span> <span class="special">&gt;</span>
        <span class="identifier">other</span><span class="special">;</span>
    <span class="special">};</span>

    <span class="comment">// construct/copy/destroy:</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span> <span class="identifier">rank_tree</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
    <span class="identifier">rank_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">rank_tree</span><span class="special">&amp;);</span>
    <span class="identifier">rank_tree</span><span class="special">(</span><span class="identifier">rank_tree</span><span class="special">&amp;&amp;);</span>
    <span class="identifier">rank_tree</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">rank_tree</span><span class="special">&amp;);</span>
    <span class="identifier">rank_tree</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">rank_tree</span><span class="special">&amp;&amp;);</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>

    <span class="comment">// cursors:</span>
    <span class="identifier">cursor</span>        <span class="identifier">root</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">root</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">croot</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">cursor</span>        <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">shoot</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">cshoot</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

    <span class="identifier">cursor</span>        <span class="identifier">rank_is</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
    <span class="identifier">const_cursor</span>  <span class="identifier">rank_is</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="identifier">size_type</span>     <span class="identifier">rank_of</span><span class="special">(</span><span class="identifier">cursor</span><span class="special">);</span>
    <span class="identifier">size_type</span>     <span class="identifier">rank_of</span><span class="special">(</span><span class="identifier">const_cursor</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>

    <span class="comment">// capacity:</span>
    <span class="keyword">bool</span>      <span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

    <span class="comment">// modifiers:</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
    <span class="identifier">cursor</span>    <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">());</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputCursor</span><span class="special">&gt;</span>
      <span class="identifier">cursor</span>  <span class="identifier">insert</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">InputCursor</span> <span class="identifier">subtree</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">rotate</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">swap</span><span class="special">(</span><span class="identifier">rank_tree</span><span class="special">&amp;);</span>
    <span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">();</span>
  <span class="special">};</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="keyword">const</span> <span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

  <span class="comment">// specialized algorithms:</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">rank_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
              Each function listed in the public interface of <code class="literal">rank_tree</code>
              as above calls a function of the same name for its adaptee object
              <code class="literal">h</code>, plus possibly other operations with guaranteed
              logarithmic time complexity in total. This means that operational semantics
              and time complexities are as specified by the <code class="literal">hierarchy_type</code>;
              and that a function can only be called if a function of the same name
              is present in the public interface of <code class="literal">hierarchy_type</code>.
              (The only exception to the above stated are the functions <code class="literal">rank_is()</code>
              and <code class="literal">rank_of()</code>, which are newly introduced.)
            </p></div><div class="section" id="tree.tree.adaptors.augment.ranktree.cursors"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.4.2.2.&#160;<a class="link" href="#tree.tree.adaptors.augment.ranktree.cursors" title="23.7.4.3.4.2.2.&#160;rank_tree cursors [ranktree.cursors]"><code class="literal">rank_tree</code>
            cursors <span class="std_section_label">[ranktree.cursors]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp7164960"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">cursor</span>        <span class="identifier">rank_is</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
<span class="identifier">const_cursor</span>  <span class="identifier">rank_is</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp7174080"><div class="titlepage"></div><p>
              <span class="emphasis"><em>Returns:</em></span> A cursor (or <code class="literal">const_cursor</code>)
              to the <code class="literal">n</code>th element of the hierarchy in inorder,
              counting from <code class="literal">inorder::begin(h)</code>.
            </p></div><div class="simplesect std_specification" id="idp7177568"><div class="titlepage"></div><p>
              <span class="emphasis"><em>Complexity:</em></span> logarithmic in <code class="literal">size()</code>.
            </p></div><div class="simplesect std_definition" id="idp7179680"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">size_type</span>     <span class="identifier">rank_of</span><span class="special">(</span><span class="identifier">cursor</span> <span class="identifier">position</span><span class="special">);</span>
<span class="identifier">size_type</span>     <span class="identifier">rank_of</span><span class="special">(</span><span class="identifier">cons_cursor</span> <span class="identifier">position</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp7188880"><div class="titlepage"></div><p>
              <span class="emphasis"><em>Returns:</em></span> The rank of element for cursor <code class="literal">position</code>
              counting from <code class="literal">inorder::begin(h)</code>.
            </p></div><div class="simplesect std_specification" id="idp7191696"><div class="titlepage"></div><p>
              <span class="emphasis"><em>Complexity:</em></span> logarithmic in <code class="literal">size()</code>.
            </p></div></div></div></div><div class="section" id="tree.tree.adaptors.balance"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.5.&#160;<a class="link" href="#tree.tree.adaptors.balance" title="23.7.4.3.5.&#160;Balancing hierarchy adaptors [hierarchy.balance]">Balancing hierarchy adaptors
        <span class="std_section_label">[hierarchy.balance]</span></a></h6></div></div></div><div class="section" id="tree.tree.adaptors.balance.general"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.5.1.&#160;<a class="link" href="#tree.tree.adaptors.balance.general" title="23.7.4.3.5.1.&#160;In general [balance.general]">In general <span class="std_section_label">[balance.general]</span></a></h6></div></div></div><div class="note"><h3 class="title">Note</h3><p>
              These do not model AssociativeContainer yet but Sequence as they permit
              insertion in arbitrary positions. (This way, they are not required
              to take care of extracting, sorting and searching.)
            </p></div><p>
            A balancing hierarchy adaptor uses some kind of balancing method in order
            to guarantee logarithmic time complexity for many important operations
            while keeping the inorder of the adaptee hierarchy as its invariant.
          </p><p>
            A balancing hierarchy adaptor satisfies all of the requirements of a
            container ([container.requirements]), of a sequence ([sequence.reqmts]),
            with the exception that its <code class="literal">erase()</code> member functions
            return <code class="literal">void</code>, and most of the optional sequence requirements,
            except for the =operator[]= and <code class="literal">at</code> member functions,
            which are not provided. If the adaptee hierarchy supports at least descending
            bidirectional cursors, it also satisfies the requirements of a reversible
            container. Descriptions are provided here only for operations on balancing
            hierarchy adaptors that are not described in one of these tables or for
            operations where there is additional semantic information.
          </p><p>
            The library provides four balancing hierarchy adaptor template classes
            which take a mutable multiway template parameter that provides a <code class="literal">rotate()</code>
            operation and whose <code class="literal">cursor</code> and <code class="literal">const_cursor</code>
            types satisfy the requirements of a binary tree cursor ([bintree.types]):
            <code class="literal">avl_tree</code>, <code class="literal">red_black_tree</code>, <code class="literal">splay_tree</code>,
            and <code class="literal">treap</code>. Furthermore, two balancing hierarchy adaptor
            template classes that take a mutable multiway tree template parameter
            are provided: <code class="literal">b_tree</code> and <code class="literal">b_star_tree</code>.
          </p><p>
            In the following, only the template class <code class="literal">avl_tree</code>
            and related operators are shown. Note that also <code class="literal">red_black_tree</code>,
            <code class="literal">splay_tree</code>, and <code class="literal">treap</code> must be present
            and have identical interfaces (with all occurrences of <code class="literal">avl_tree</code>
            replaced accordingly). The same holds true for <code class="literal">b_tree</code>
            and <code class="literal">b_star_tree</code>, as well, except that the standard
            value for the template parameter reads <code class="literal">multiway_tree&lt;T&gt;</code>
            (instead of <code class="literal">binary_tree&lt;T&gt;</code>) in their case.
          </p><div class="simplesect std_paragraph" id="idp7216800"><div class="titlepage"></div><p>
            <span class="bold"><strong>Header <code class="literal">&lt;avl_tree&gt;</code> synopsis</strong></span>
          </p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">initializer_list</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">avl_tree</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
            <span class="bold"><strong>Header <code class="literal">&lt;red_black_tree&gt;</code>
            synopsis</strong></span>
          </p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">initializer_list</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">red_black_tree</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">red_black_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
            <span class="bold"><strong>Header <code class="literal">&lt;splay_tree&gt;</code> synopsis</strong></span>
          </p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">initializer_list</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">splay_tree</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">splay_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
            <span class="bold"><strong>Header <code class="literal">&lt;treap&gt;</code> synopsis</strong></span>
          </p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">initializer_list</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">treap</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">treap</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
            <span class="bold"><strong>Header <code class="literal">&lt;b_tree&gt;</code> synopsis</strong></span>
          </p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">initializer_list</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">b_tree</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">b_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
            <span class="bold"><strong>Header <code class="literal">&lt;b_star_tree&gt;</code> synopsis</strong></span>
          </p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">initializer_list</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">multiway_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">b_star_tree</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">b_star_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div></div><div class="section" id="tree.tree.adaptors.balance.avltree"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.5.2.&#160;<a class="link" href="#tree.tree.adaptors.balance.avltree" title="23.7.4.3.5.2.&#160;Class template avl_tree [balance.avltree]">Class template
          <code class="literal">avl_tree</code> <span class="std_section_label">[balance.avltree]</span></a></h6></div></div></div><div class="section" id="tree.tree.adaptors.balance.avltree.defn"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.5.2.1.&#160;<a class="link" href="#tree.tree.adaptors.balance.avltree.defn" title="23.7.4.3.5.2.1.&#160;avl_tree definition [balance.defn]"><code class="literal">avl_tree</code>
            definition <span class="std_section_label">[balance.defn]</span></a></h6></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span> <span class="special">=</span> <span class="identifier">binary_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span>
  <span class="keyword">class</span> <span class="identifier">avl_tree</span> <span class="special">{</span>
  <span class="keyword">public</span><span class="special">:</span>
    <span class="keyword">typedef</span> <span class="identifier">Hierarchy</span>                                     <span class="identifier">hierarchy_type</span><span class="special">;</span>

  <span class="keyword">protected</span><span class="special">:</span>
    <span class="identifier">hierarchy_type</span> <span class="identifier">h</span><span class="special">;</span>

  <span class="keyword">public</span><span class="special">:</span>
    <span class="comment">// types:</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">reference</span>            <span class="identifier">reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">const_reference</span>      <span class="identifier">const_reference</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">iterator</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span>                        <span class="identifier">const_iterator</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">size_type</span>            <span class="identifier">size_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">difference_type</span>      <span class="identifier">difference_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">value_type</span>           <span class="identifier">value_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">allocator_type</span>       <span class="identifier">alocator_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">pointer</span>              <span class="identifier">pointer</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">hierarchy_type</span><span class="special">::</span><span class="identifier">const_pointer</span>        <span class="identifier">const_pointer</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">reverse_iterator</span><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">&gt;</span>               <span class="identifier">reverse_iterator</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">reverse_iterator</span><span class="special">&lt;</span><span class="identifier">const_iterator</span><span class="special">&gt;</span>         <span class="identifier">const_reverse_iterator</span><span class="special">;</span>

    <span class="comment">// construct/copy/destroy:</span>
    <span class="keyword">explicit</span> <span class="identifier">avl_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Hierarchy</span><span class="special">&amp;);</span>
    <span class="keyword">explicit</span> <span class="identifier">avl_tree</span><span class="special">(</span><span class="identifier">Hierarchy</span><span class="special">&amp;&amp;</span> <span class="special">=</span> <span class="identifier">Hierarchy</span><span class="special">());</span>
    <span class="identifier">avl_tree</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Hierarchy</span><span class="special">&amp;);</span>
    <span class="identifier">avl_tree</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&amp;&amp;</span> <span class="special">=</span> <span class="identifier">Hierarchy</span><span class="special">());</span>
    <span class="identifier">avl_tree</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">value</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Hierarchy</span><span class="special">&amp;);</span>
    <span class="identifier">avl_tree</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">value</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&amp;&amp;</span> <span class="special">=</span> <span class="identifier">Hierarchy</span><span class="special">());</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator</span><span class="special">&gt;</span>
      <span class="identifier">avl_tree</span><span class="special">(</span><span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span>
        <span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">Hierarchy</span><span class="special">());</span>
    <span class="identifier">avl_tree</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
    <span class="identifier">avl_tree</span><span class="special">(</span><span class="identifier">avl_tree</span><span class="special">&amp;&amp;);</span>
    <span class="identifier">avl_tree</span><span class="special">(</span><span class="identifier">initializer_list</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;);</span>
    <span class="identifier">avl_tree</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&amp;);</span>
    <span class="identifier">avl_tree</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">avl_tree</span><span class="special">&amp;&amp;);</span>
    <span class="identifier">avl_tree</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="identifier">initializer_list</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;);</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator</span><span class="special">&gt;</span>
      <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">);</span>
    <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
    <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">initializer_list</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;);</span>

    <span class="comment">// iterators:</span>
    <span class="identifier">iterator</span>                <span class="identifier">begin</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_iterator</span>          <span class="identifier">begin</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">iterator</span>                <span class="identifier">end</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">{</span> <span class="keyword">return</span> <span class="identifier">iterator</span><span class="special">(</span><span class="identifier">h</span><span class="special">.</span><span class="identifier">shoot</span><span class="special">());</span> <span class="special">}</span>
    <span class="identifier">const_iterator</span>          <span class="identifier">end</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">const_iterator</span><span class="special">(</span><span class="identifier">h</span><span class="special">.</span><span class="identifier">cshoot</span><span class="special">());</span> <span class="special">}</span>
    <span class="identifier">reverse_iterator</span>        <span class="identifier">rbegin</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_reverse_iterator</span>  <span class="identifier">rbegin</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">reverse_iterator</span>        <span class="identifier">rend</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_reverse_iterator</span>  <span class="identifier">rend</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_iterator</span>          <span class="identifier">cbegin</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_iterator</span>          <span class="identifier">cend</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">const_iterator</span><span class="special">(</span><span class="identifier">h</span><span class="special">.</span><span class="identifier">cshoot</span><span class="special">());</span> <span class="special">}</span>
    <span class="identifier">const_reverse_iterator</span>  <span class="identifier">crbegin</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="identifier">const_reverse_iterator</span>  <span class="identifier">crend</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

    <span class="comment">// capacity:</span>
    <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">h</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">}</span>
    <span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
    <span class="keyword">void</span>      <span class="identifier">resize</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">sz</span><span class="special">);</span>
    <span class="keyword">void</span>      <span class="identifier">resize</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">sz</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
    <span class="keyword">bool</span>      <span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">h</span><span class="special">.</span><span class="identifier">empty</span><span class="special">();</span> <span class="special">}</span>

    <span class="comment">// element access:</span>
    <span class="identifier">reference</span>       <span class="identifier">front</span><span class="special">();</span>
    <span class="identifier">const_reference</span> <span class="identifier">front</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="identifier">reference</span>       <span class="identifier">back</span><span class="special">();</span>
    <span class="identifier">const_reference</span> <span class="identifier">back</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>

    <span class="comment">// modifiers:</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">emplace_front</span><span class="special">(</span><span class="identifier">Args</span><span class="special">&amp;&amp;...);</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">emplace_back</span><span class="special">(</span><span class="identifier">Args</span><span class="special">&amp;&amp;...);</span>
    <span class="keyword">void</span> <span class="identifier">push_front</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
    <span class="keyword">void</span> <span class="identifier">push_front</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;&amp;);</span>
    <span class="keyword">void</span> <span class="identifier">push_back</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
    <span class="keyword">void</span> <span class="identifier">push_back</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;&amp;);</span>
    <span class="keyword">void</span> <span class="identifier">pop_front</span><span class="special">();</span>
    <span class="keyword">void</span> <span class="identifier">pop_back</span><span class="special">();</span>

    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="identifier">iterator</span> <span class="identifier">emplace</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;);</span>
    <span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
    <span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;);</span>
    <span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
    <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator</span><span class="special">&gt;</span>
      <span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span>
        <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">);</span>
    <span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">initializer_list</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;);</span>
    <span class="identifier">iterator</span> <span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">);</span>
    <span class="identifier">iterator</span> <span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="identifier">last</span><span class="special">);</span>
    <span class="keyword">void</span>     <span class="identifier">swap</span><span class="special">(</span><span class="identifier">avl_tree</span><span class="special">&amp;);</span>
    <span class="keyword">void</span>     <span class="identifier">clear</span><span class="special">()</span> <span class="keyword">noexcept</span> <span class="special">{</span> <span class="identifier">h</span><span class="special">.</span><span class="identifier">clear</span><span class="special">();</span> <span class="special">}</span>
  <span class="special">};</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&gt;=(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">&lt;=(</span><span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>

  <span class="comment">// specialized algorithms:</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" id="tree.tree.adaptors.balance.avltree.cons"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.5.2.2.&#160;<a class="link" href="#tree.tree.adaptors.balance.avltree.cons" title="23.7.4.3.5.2.2.&#160;Balancing adaptor constructors, copy, and assigment [balance.cons]">Balancing
            adaptor constructors, copy, and assigment <span class="std_section_label">[balance.cons]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp8439136"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator</span><span class="special">&gt;</span>
  <span class="identifier">avl_tree</span><span class="special">(</span><span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">,</span>
    <span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">Hierarchy</span><span class="special">());</span>
</pre></div><div class="simplesect std_specification" id="idp8451376"><div class="titlepage"></div><p>
              <span class="emphasis"><em>Effects:</em></span> constructs a balanced tree equal to the
              range [<code class="literal">first</code>, <code class="literal">last</code>).
            </p></div><div class="simplesect std_specification" id="idp8454160"><div class="titlepage"></div><p>
              <span class="emphasis"><em>Complexity:</em></span> Linear.
            </p></div><div class="simplesect std_definition" id="idp8455616"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">assign</span><span class="special">(</span><span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp8464976"><div class="titlepage"></div><p>
              <span class="emphasis"><em>Effects:</em></span>
            </p><pre class="programlisting"><span class="identifier">clear</span><span class="special">();</span>
<span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span><span class="special">++</span> <span class="special">!=</span> <span class="identifier">last</span><span class="special">)</span>
  <span class="identifier">insert</span><span class="special">(</span><span class="identifier">end</span><span class="special">(),</span> <span class="special">*</span><span class="identifier">first</span><span class="special">);</span>
</pre></div></div><div class="section" id="tree.tree.adaptors.balance.avltree.modifiers"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.5.2.3.&#160;<a class="link" href="#tree.tree.adaptors.balance.avltree.modifiers" title="23.7.4.3.5.2.3.&#160;Balancing adaptor modifiers [balance.modifiers]">Balancing
            adaptor modifiers <span class="std_section_label">[balance.modifiers]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp8478176"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">emplace_front</span><span class="special">(</span><span class="identifier">Args</span><span class="special">&amp;&amp;...);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">emplace_back</span><span class="special">(</span><span class="identifier">Args</span><span class="special">&amp;&amp;...);</span>
<span class="keyword">void</span> <span class="identifier">push_front</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
<span class="keyword">void</span> <span class="identifier">push_front</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;&amp;);</span>
<span class="keyword">void</span> <span class="identifier">push_back</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
<span class="keyword">void</span> <span class="identifier">push_back</span><span class="special">(</span><span class="identifier">T</span><span class="special">&amp;&amp;);</span>
<span class="keyword">void</span> <span class="identifier">pop_front</span><span class="special">();</span>
<span class="keyword">void</span> <span class="identifier">pop_back</span><span class="special">();</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span> <span class="identifier">iterator</span> <span class="identifier">emplace</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">Args</span><span class="special">&amp;&amp;);</span>
<span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
<span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&amp;&amp;);</span>
<span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator</span><span class="special">&gt;</span>
  <span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span>
    <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">);</span>
<span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">initializer_list</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;);</span>
</pre></div><div class="simplesect std_specification" id="idp8548128"><div class="titlepage"></div><p>
              <span class="emphasis"><em>Complexity:</em></span> linear in the number of elements to
              insert when inserting more than one element, otherwise amortized contant.
            </p></div><div class="simplesect std_definition" id="idp8549696"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">void</span>      <span class="identifier">erase</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="identifier">last</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp8556112"><div class="titlepage"></div><p>
              <span class="emphasis"><em>Complexity:</em></span> <code class="literal">log(size())+N</code> where
              <code class="literal">N</code> is the distance from <code class="literal">first</code>
              to <code class="literal">last</code>
            </p></div><div class="simplesect std_definition" id="idp8560176"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">void</span>      <span class="identifier">clear</span><span class="special">();</span>
</pre></div><div class="simplesect std_specification" id="idp8563168"><div class="titlepage"></div><p>
              <span class="emphasis"><em>Complexity:</em></span> <code class="literal">log(size())+N</code>
            </p></div></div><div class="section" id="tree.tree.adaptors.balance.avltree.special"><div class="titlepage"><div><div><h6 class="title">23.7.4.3.5.2.4.&#160;<a class="link" href="#tree.tree.adaptors.balance.avltree.special" title="23.7.4.3.5.2.4.&#160;Balancing adaptor specialized algorithms [balance.special]">Balancing
            adaptor specialized algorithms <span class="std_section_label">[balance.special]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp8567648"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
  <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;,</span> <span class="identifier">avl_tree</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Hierarchy</span><span class="special">&gt;&amp;);</span>
</pre></div><div class="simplesect std_specification" id="idp8581760"><div class="titlepage"></div><p>
              <span class="emphasis"><em>Effects:</em></span> <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">y</span><span class="special">);</span></code>
            </p></div></div></div></div></div></div></div></div><div class="section std_section" id="tree.proposal.iterators"><div class="titlepage"><div><div><h3 class="title">24.&#160;<a class="link" href="#tree.proposal.iterators" title="24.&#160;Iterators library [iterators]">Iterators library
  <span class="std_section_label">[iterators]</span></a></h3></div></div></div><div class="section std_section" id="iterator.synopsis"><div class="titlepage"><div><div><h4 class="title">24.3.&#160;<a class="link" href="#iterator.synopsis" title="24.3.&#160;Headers &lt;iterator&gt; synopsis [iterator.synopsis]">Headers
  <code class="literal">&lt;iterator&gt;</code> synopsis <span class="std_section_label">[iterator.synopsis]</span></a></h4></div></div></div><div class="note"><h3 class="title">Note</h3><p>
      Insert after section introduced with <code class="computeroutput"><span class="comment">// 24.6.5,
      range access:</span></code>
    </p></div><pre class="programlisting"><span class="comment">// 24.7, linear order traversal iterators</span>
<span class="keyword">namespace</span> <span class="identifier">preorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">iterator</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span>
      <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
      <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span>
    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span>
      <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
      <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace preorder   </span>

<span class="keyword">namespace</span> <span class="identifier">postorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">iterator</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace postorder   </span>

<span class="keyword">namespace</span> <span class="identifier">inorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">iterator</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace inorder</span>
</pre></div><div class="section std_section" id="cursors"><div class="titlepage"><div><div><h4 class="title">24.7.&#160;<a class="link" href="#cursors" title="24.7.&#160;Cursors [cursors]">Cursors <span class="std_section_label">[cursors]</span></a></h4></div></div></div><div class="note"><h3 class="title">Note</h3><p>
      Add after subclause 24.7, Stream iterators ([stream.iterators]):
    </p></div><p>
    Cursors provide a uniform way of applying algorithms to hierarchical data structures.
    In order to also allow for algorithms relevant when dealing with linear data
    structures, any cursor class is actually a refinement of a corresponding iterator
    class.
  </p><p>
    If exactly one application of the expression <code class="computeroutput"><span class="identifier">i</span>
    <span class="special">=</span> <span class="identifier">i</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span></code>,
    followed by a finite sequence of applications of the expression <code class="computeroutput"><span class="special">++</span><span class="identifier">j</span></code> makes
    <code class="computeroutput"><span class="identifier">i</span> <span class="special">==</span>
    <span class="identifier">j</span></code>, <code class="computeroutput"><span class="identifier">j</span></code>
    is a <span class="emphasis"><em>child</em></span> (or <span class="emphasis"><em>immediate descendant</em></span>)
    of <code class="computeroutput"><span class="identifier">i</span></code>, and <code class="computeroutput"><span class="identifier">i</span></code>
    is the <span class="emphasis"><em>parent</em></span> (or the <span class="emphasis"><em>immediate ancestor</em></span>)
    of <code class="computeroutput"><span class="identifier">j</span></code>. A cursor <code class="computeroutput"><span class="identifier">j</span></code> is another cursor <code class="computeroutput"><span class="identifier">i</span></code>'s
    descendant if there is a finite sequential combination of applications of the
    expressions <code class="computeroutput"><span class="special">++</span><span class="identifier">i</span></code>
    and <code class="computeroutput"><span class="identifier">i</span> <span class="special">=</span>
    <span class="identifier">i</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span></code> that
    makes <code class="computeroutput"><span class="identifier">i</span> <span class="special">==</span>
    <span class="identifier">j</span></code>; <code class="computeroutput"><span class="identifier">i</span></code>
    is then called <code class="computeroutput"><span class="identifier">j</span></code>'s ancestor.
    If two cursors <code class="computeroutput"><span class="identifier">i</span></code> and <code class="computeroutput"><span class="identifier">j</span></code> share at least one common ancestor, they
    refer to the same container. The descending traversal capabilities of a class
    relate to the range of children of a given instance of that class.
  </p><p>
    In addition to a cursor's descending traversal tags, two of them are reused to
    indicate a cursor's ascending traversal abilities, namely <span class="emphasis"><em>forward</em></span>
    and <span class="emphasis"><em>bidirectional</em></span> traversal in order to indicate whether
    a given cursor provides traversal to the parent.
  </p><p>
    Apart from cursors that are <span class="emphasis"><em>past-the-end</em></span> (like their iterator
    counterparts can be), the notion of a cursor <span class="emphasis"><em>on-top</em></span> is introduced,
    denoting a cursor that is ancestor to all other cursors within a hierarchy; and
    just as for past-the-end ones, the library generally does not assume on-top cursors
    be dereferenceable.
  </p><p>
    A cursor <code class="computeroutput"><span class="identifier">c</span></code> for which <code class="computeroutput"><span class="identifier">c</span><span class="special">.</span><span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="keyword">true</span></code>
    is called a <span class="emphasis"><em>leaf cursor</em></span>. A leaf cursor's children are never
    assumed to be dereferenceable. A cursor which is either on-top or a descendant
    of an on-top cursor, but in either case not a leaf cursor, nor a descendant of
    a leaf cursor, is called an <span class="emphasis"><em>internal cursor</em></span>.
  </p><p>
    A cursor, like an iterator, can have a singular value that is not associated
    with any hierarchy, meaning that most expressions are undefined for it, with
    the exception of assignment of a non-singular value to a cursor that holds a
    singular value. The children of a leaf cursor's child are never assumed to be
    non-singular; nor is the parent of an on-top node.
  </p><p>
    Like for iterators, the Standard defines a number of categories of cursors according
    to the operations defined on them: <span class="emphasis"><em>cursor</em></span>, <span class="emphasis"><em>descending
    cursor</em></span>, <span class="emphasis"><em>descending forward cursor</em></span>, <span class="emphasis"><em>descending
    bidirectional cursor</em></span>, <span class="emphasis"><em>descending random access cursor</em></span>,
    <span class="emphasis"><em>ascending cursor</em></span>, <span class="emphasis"><em>ascending forward cursor</em></span>,
    <span class="emphasis"><em>ascending bidirectional</em></span> , and <span class="emphasis"><em>ascending random
    access cursor</em></span>. The cursors of any <span class="emphasis"><em>ascending</em></span> category
    generally support all the operations of their <span class="emphasis"><em>descending</em></span>
    counterpart, plus a method to obtain their parent; relations between the <span class="emphasis"><em>forward</em></span>,
    <span class="emphasis"><em>bidirectional</em></span> and <span class="emphasis"><em>random access</em></span> parts
    are as for iterators of those categories.
  </p><p>
    In the following sections <code class="literal">X</code> denotes a cursor over values of
    type <code class="literal">T</code>, <code class="literal">a</code> and <code class="literal">b</code> denotes
    an identifier, <code class="literal">r</code> denotes a value of <code class="literal">T&amp;</code>
    and <code class="literal">t</code> denotes a value of type <code class="literal">T</code>.
  </p><div class="section" id="tree.cursor_requirements"><div class="titlepage"><div><div><h5 class="title">24.7.1.&#160;<a class="link" href="#tree.cursor_requirements" title="24.7.1.&#160;Cursor requirements [cursor.requirements]">Cursor requirements <span class="std_section_label">[cursor.requirements]</span></a></h5></div></div></div><div class="simplesect std_requisite" id="idp8754848"><div class="titlepage"></div><p>
      A class <code class="literal">X</code> satisfies the requirements of a cursor if the
      following expressions are valid, as shown in Table 8, in addition to satisfying
      the requirements of input iterators ([input.iterators]) and output iterators
      ([output.iterators]):
    </p><div class="table" id="tree.cursor_requirements.table8"><div class="table-title">Table&#160;8.&#160; Cursor requirements (in addition to input and output iterators)</div><div class="table-contents"><table class="table" summary=" Cursor requirements (in addition to input and output iterators)"><colgroup><col><col><col><col></colgroup><thead><tr><th>
              <p>
                expression
              </p>
            </th><th>
              <p>
                return type
              </p>
            </th><th>
              <p>
                operational semantics
              </p>
            </th><th>
              <p>
                assertion/note <br> pre/post-condition
              </p>
            </th></tr></thead><tbody><tr><td>
              <p>
                <code class="literal">X::value_type</code>
              </p>
            </td><td>
              <p>
                <code class="literal">T</code>
              </p>
            </td><td>
              <p>
                Any non-reference, non-cv-qualified type
              </p>
            </td><td>
              <p>
                compile time
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">X::type</code>
              </p>
            </td><td>
              <p>
                Convertible to <code class="literal">cursor_tag</code>, <code class="literal">input_iterator_tag</code>,
                and <code class="literal">output_iterator_tag</code>
              </p>
            </td><td>
            </td><td>
              <p>
                compile time
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">X::cursor</code>
              </p>
            </td><td>
              <p>
                Convertible to <code class="literal">X</code>
              </p>
            </td><td>
            </td><td>
              <p>
                compile time
              </p>
            </td></tr><tr><td>
              <p>
                <code class="literal">X::const_cursor</code>
              </p>
            </td><td>
              <p>
                Convertible to <code class="literal">const X</code>
              </p>
            </td><td>
            </td><td>
              <p>
                compile time
              </p>
            </td></tr></tbody></table></div></div><br class="table-break"></div><div class="section" id="tree.cursor_requirements.descending"><div class="titlepage"><div><div><h6 class="title">24.7.1.1.&#160;<a class="link" href="#tree.cursor_requirements.descending" title="24.7.1.1.&#160;Descending Cursor [descending.cursors]">Descending Cursor
      <span class="std_section_label">[descending.cursors]</span></a></h6></div></div></div><div class="simplesect std_requisite" id="idp8785328"><div class="titlepage"></div><p>
        A class <code class="literal">X</code> satisfies the requirements of a descending cursor
        if, in addition to satisfying the requirements for cursors ([cursor.requirements])
        it also conforms to the container requirements ([container.requirements])
        with the exception of the following expressions:
      </p><div class="table" id="tree.cursor_requirements.descending.table9"><div class="table-title">Table&#160;9.&#160; Container requirements that are not supported</div><div class="table-contents"><table class="table" summary=" Container requirements that are not supported"><colgroup><col></colgroup><thead><tr><th>
                <p>
                  unsupported expression
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">iterator</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">const_iterator</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">reverse_iterator</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">reverse_const_iterator</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="special">(&amp;</span><span class="identifier">a</span><span class="special">)-&gt;~</span><span class="identifier">X</span><span class="special">();</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">(</span><span class="identifier">a</span><span class="special">);</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span> <span class="identifier">u</span><span class="special">(</span><span class="identifier">a</span><span class="special">);</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span> <span class="identifier">u</span>
                  <span class="special">=</span> <span class="identifier">a</span><span class="special">;</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">begin</span><span class="special">()</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">rbegin</span><span class="special">()</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">rend</span><span class="special">()</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span> <span class="special">==</span>
                  <span class="identifier">b</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span> <span class="special">!=</span>
                  <span class="identifier">b</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">r</span> <span class="special">=</span>
                  <span class="identifier">a</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span> <span class="special">&lt;</span>
                  <span class="identifier">b</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span> <span class="special">&gt;</span>
                  <span class="identifier">b</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span> <span class="special">&lt;=</span>
                  <span class="identifier">b</span></code>
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span> <span class="special">&gt;=</span>
                  <span class="identifier">b</span></code>
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"><p>
        Notes: The expressions <code class="literal">a.begin()</code> and <code class="literal">a.end()</code>
        are, as shown in Table 9, replaced with equivalent expressions for cursors.
      </p></div><div class="simplesect std_requisite" id="idp8867264"><div class="titlepage"></div><p>
        Additionally, for a descending cursor, the following expression are valid,
        as shown in Table 10:
      </p><div class="table" id="tree.cursor_requirements.descending.table10"><div class="table-title">Table&#160;10.&#160; Descending cursor requirements (in addition to cursor)</div><div class="table-contents"><table class="table" summary=" Descending cursor requirements (in addition to cursor)"><colgroup><col><col><col><col></colgroup><thead><tr><th>
                <p>
                  expression
                </p>
              </th><th>
                <p>
                  return type
                </p>
              </th><th>
                <p>
                  operational semantics
                </p>
              </th><th>
                <p>
                  assertion/note <br> pre/post-condition
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="literal">X::type</code>
                </p>
              </td><td>
                <p>
                  Convertible to <code class="literal">descending_cursor_tag</code>
                </p>
              </td><td>
              </td><td>
                <p>
                  compile time
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.begin()</code>
                </p>
              </td><td>
                <p>
                  <code class="literal">cursor</code> or <code class="literal">const_cursor</code> for
                  constant <code class="literal">a</code>
                </p>
              </td><td>
                <p>
                  pre: <code class="literal">a</code> is non-leaf.
                </p>
              </td><td>
                <p>
                  constant
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.end()</code>
                </p>
              </td><td>
                <p>
                  <code class="literal">cursor</code> or <code class="literal">const_cursor</code> for
                  constant <code class="literal">a</code>
                </p>
              </td><td>
                <p>
                  pre: <code class="literal">a</code> is non-leaf.
                </p>
              </td><td>
                <p>
                  constant
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.cbegin()</code>
                </p>
              </td><td>
                <p>
                  <code class="literal">const_cursor</code>
                </p>
              </td><td>
                <p>
                  pre: <code class="literal">a</code> is non-leaf.
                </p>
              </td><td>
                <p>
                  constant
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.cend()</code>
                </p>
              </td><td>
                <p>
                  <code class="literal">const_cursor</code>
                </p>
              </td><td>
                <p>
                  pre: <code class="literal">a</code> is non-leaf.
                </p>
              </td><td>
                <p>
                  constant
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="literal">a.parity()</code>
                </p>
              </td><td>
                <p>
                  <code class="literal">size_type</code>
                </p>
              </td><td>
                <p>
                  <code class="literal">std::distance(b.begin(), a)</code> if <code class="literal">b</code>
                  is <code class="literal">a</code>'s parent. <br> pre: <code class="literal">a</code>
                  is non-on-top.
                </p>
              </td><td>
                <p>
                  Linear in <code class="literal">b.size()</code>
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"></div></div><div class="section" id="tree.cursor_requirements.descending_forward"><div class="titlepage"><div><div><h6 class="title">24.7.1.2.&#160;<a class="link" href="#tree.cursor_requirements.descending_forward" title="24.7.1.2.&#160;Descending Forward Cursor [descending.forward.cursors]">Descending
      Forward Cursor <span class="std_section_label">[descending.forward.cursors]</span></a></h6></div></div></div><p>
        A class type <code class="literal">X</code> satisfies the requirements of a descending
        forward cursor if the following expressions are valid, as shown in Table
        11, in addition to the requirements of descending cursors ([descending.cursors])
        and forward iterators ([forward.iterators]):
      </p><div class="table" id="tree.cursor_requirements.descending_forward.table11"><div class="table-title">Table&#160;11.&#160; Descending forward cursor requirements (in addition to descending
        cursors and forward iterators)</div><div class="table-contents"><table class="table" summary=" Descending forward cursor requirements (in addition to descending
        cursors and forward iterators)"><colgroup><col><col><col><col></colgroup><thead><tr><th>
                <p>
                  expression
                </p>
              </th><th>
                <p>
                  return type
                </p>
              </th><th>
                <p>
                  operational semantics
                </p>
              </th><th>
                <p>
                  assertion/note <br> pre/post-condition
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="literal">X::type</code>
                </p>
              </td><td>
                <p>
                  Convertible to <code class="literal">descending_forward_cursor_tag</code>
                  and <code class="literal">forward_iterator_tag</code>
                </p>
              </td><td>
              </td><td>
                <p>
                  compile time
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"></div><div class="section" id="tree.cursor_requirements.descending_bidirectional"><div class="titlepage"><div><div><h6 class="title">24.7.1.3.&#160;<a class="link" href="#tree.cursor_requirements.descending_bidirectional" title="24.7.1.3.&#160;Descending Bidirectional Cursor [descending.bidirectional.cursors]">Descending
      Bidirectional Cursor <span class="std_section_label">[descending.bidirectional.cursors]</span></a></h6></div></div></div><p>
        A class type <code class="literal">X</code> satisfies the requirements of a descending
        bidirectional cursor if the following expressions are valid, as shown in
        Table 12, in addition to satisfying the requirements for descending forward
        cursors ([descending.forward.cursors]) and bidirectional iterators ([bidirectional.iterators]):
      </p><div class="table" id="tree.cursor_requirements.descending_bidirectional.table12"><div class="table-title">Table&#160;12.&#160; Descending bidirectional cursor requirements (in addition to forward
        descending cursors and bidirectional iterators)</div><div class="table-contents"><table class="table" summary=" Descending bidirectional cursor requirements (in addition to forward
        descending cursors and bidirectional iterators)"><colgroup><col><col><col><col></colgroup><thead><tr><th>
                <p>
                  expression
                </p>
              </th><th>
                <p>
                  return type
                </p>
              </th><th>
                <p>
                  operational semantics
                </p>
              </th><th>
                <p>
                  assertion/note <br> pre/post-condition
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">type</span></code>
                </p>
              </td><td>
                <p>
                  Convertible to <code class="literal">descending_bidirectional_cursor_tag</code>
                  and <code class="literal">bidirectional_iterator_tag</code>
                </p>
              </td><td>
              </td><td>
                <p>
                  compile time
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"><div class="note"><h3 class="title">Note</h3><p>
          rbegin() and rend() do not seem very useful for multiway trees, as they
          hide end() and its possible children. Are different semantics or maybe
          having rend() stand in for end() sensible solutions? Or just ignore this
          aspect?
        </p></div></div><div class="section" id="tree.cursor_requirements.descending_random_access"><div class="titlepage"><div><div><h6 class="title">24.7.1.4.&#160;<a class="link" href="#tree.cursor_requirements.descending_random_access" title="24.7.1.4.&#160;Descending Random Access Cursor [descending.random.access.cursors]">Descending
      Random Access Cursor <span class="std_section_label">[descending.random.access.cursors]</span></a></h6></div></div></div><p>
        A class type <code class="literal">X</code> satisfies the requirements of a descending
        random access cursor if the following expressions are valid, as shown in
        Table 13, in addition to satisfying the requirements for descending bidirectional
        cursors ([descending.bidirectional.cursors]) and random access iterators
        ([random.access.iterators]):
      </p><div class="table" id="tree.cursor_requirements.descending_random_access.table13"><div class="table-title">Table&#160;13.&#160; Descending random access cursor requirements (in addition to descending
        bidirectional cursors and random access iterators)</div><div class="table-contents"><table class="table" summary=" Descending random access cursor requirements (in addition to descending
        bidirectional cursors and random access iterators)"><colgroup><col><col><col><col></colgroup><thead><tr><th>
                <p>
                  expression
                </p>
              </th><th>
                <p>
                  return type
                </p>
              </th><th>
                <p>
                  operational semantics
                </p>
              </th><th>
                <p>
                  assertion/note <br> pre/post-condition
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">type</span></code>
                </p>
              </td><td>
                <p>
                  Convertible to <code class="literal">descending_random_access_cursor_tag</code>
                  and <code class="literal">random_access_iterator_tag</code>
                </p>
              </td><td>
              </td><td>
                <p>
                  compile time
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"></div><div class="section" id="tree.cursor_requirements.ascending"><div class="titlepage"><div><div><h6 class="title">24.7.1.5.&#160;<a class="link" href="#tree.cursor_requirements.ascending" title="24.7.1.5.&#160;Ascending Cursor [ascending.cursors]">Ascending Cursor
      <span class="std_section_label">[ascending.cursors]</span></a></h6></div></div></div><div class="simplesect std_requisite" id="idp8966416"><div class="titlepage"></div><p>
        A class type <code class="literal">X</code> satisfies the requirements of an ascending
        cursor if the following expressions are valid, as shown in Table 14, in addition
        to satisfying the requirements for descending cursors ([descending.cursors]):
      </p><div class="table" id="tree.cursor_requirements.ascending.table14"><div class="table-title">Table&#160;14.&#160; Ascending cursor requirements (in addition to descending cursors)</div><div class="table-contents"><table class="table" summary=" Ascending cursor requirements (in addition to descending cursors)"><colgroup><col><col><col><col></colgroup><thead><tr><th>
                <p>
                  expression
                </p>
              </th><th>
                <p>
                  return type
                </p>
              </th><th>
                <p>
                  operational semantics
                </p>
              </th><th>
                <p>
                  assertion/note<br> pre/post-condition
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">type</span></code>
                </p>
              </td><td>
                <p>
                  Convertible to <code class="literal">ascending_cursor_tag</code>
                </p>
              </td><td>
              </td><td>
                <p>
                  compile time
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="identifier">a</span><span class="special">.</span><span class="identifier">parent</span><span class="special">()</span></code>
                </p>
              </td><td>
                <p>
                  <code class="literal">cursor</code>; <code class="literal">const_cursor</code> for
                  a constant <code class="literal">a</code>
                </p>
              </td><td>
              </td><td>
                <p>
                  (Note A)
                </p>
              </td></tr><tr><td>
                <p>
                  <code class="computeroutput"><span class="special">!</span><span class="identifier">r</span></code>
                </p>
              </td><td>
                <p>
                  <code class="computeroutput"><span class="identifier">X</span><span class="special">&amp;</span></code>
                </p>
              </td><td>
                <p>
                  <code class="computeroutput"><span class="identifier">r</span> <span class="special">=</span>
                  <span class="identifier">r</span><span class="special">.</span><span class="identifier">parent</span><span class="special">();</span></code>
                </p>
              </td><td>
                <p>
                  pre: <code class="literal">r</code> is an internal, non-on-top cursor. <br>
                  post: <code class="literal">r</code> is internal. <br> <code class="computeroutput"><span class="identifier">r</span>
                  <span class="special">==</span> <span class="identifier">s</span></code>
                  and <code class="computeroutput"><span class="identifier">r</span></code> is internal
                  and non-on-top implies <code class="computeroutput"><span class="special">!</span><span class="identifier">r</span> <span class="special">==</span>
                  <span class="special">!</span><span class="identifier">s</span></code>.
                  <br> <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">r</span>
                  <span class="special">==</span> <span class="special">&amp;!</span><span class="identifier">r</span></code> <br> (Note A)
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"><p>
        <span class="emphasis"><em>Notes:</em></span> Those entries marked "(Note A)" shall
        have at worst linear complexity. See the individual hierarchy containers
        for specific complexity.
      </p></div></div><div class="section" id="tree.cursor_requirements.ascending_forward"><div class="titlepage"><div><div><h6 class="title">24.7.1.6.&#160;<a class="link" href="#tree.cursor_requirements.ascending_forward" title="24.7.1.6.&#160;Ascending Forward Cursor [ascending.forward.cursors]">Ascending
      Forward Cursor <span class="std_section_label">[ascending.forward.cursors]</span></a></h6></div></div></div><p>
        A class type <code class="literal">X</code> satisfies the requirements of an ascending
        forward cursor if the following expressions are valid, as shown in Table
        15, in addition to satisfying the requirements for ascending cursors ([ascending.cursors])
        and descending forward cursors ([descending.forward.cursors]):
      </p><div class="table" id="tree.cursor_requirements.ascending_forward.table15"><div class="table-title">Table&#160;15.&#160; Ascending forward cursor requirements (in addition to ascending cursors
        and descending forward cursors)</div><div class="table-contents"><table class="table" summary=" Ascending forward cursor requirements (in addition to ascending cursors
        and descending forward cursors)"><colgroup><col><col><col><col></colgroup><thead><tr><th>
                <p>
                  expression
                </p>
              </th><th>
                <p>
                  return type
                </p>
              </th><th>
                <p>
                  operational semantics
                </p>
              </th><th>
                <p>
                  assertion/note<br> pre/post-condition
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="literal">X::type</code>
                </p>
              </td><td>
                <p>
                  Convertible to <code class="literal">ascending_forward_cursor_tag</code>
                </p>
              </td><td>
              </td><td>
                <p>
                  compile time
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"></div><div class="section" id="tree.cursor_requirements.ascending_bidirectional"><div class="titlepage"><div><div><h6 class="title">24.7.1.7.&#160;<a class="link" href="#tree.cursor_requirements.ascending_bidirectional" title="24.7.1.7.&#160;Ascending Bidirectional Cursor [ascending.bidirectional.cursors]">Ascending
      Bidirectional Cursor <span class="std_section_label">[ascending.bidirectional.cursors]</span></a></h6></div></div></div><p>
        A class type <code class="literal">X</code> satisfies the requirements of an ascending
        bidirectional cursor if the following expressions are valid, as shown in
        Table 16, in addition to satisfying the requirements of ascending forward
        cursors ([ascending.forward.cursors]) and descending bidirectional cursors
        ([descending.bidirectional.cursors]):
      </p><div class="table" id="tree.cursor_requirements.ascending_bidirectional.table16"><div class="table-title">Table&#160;16.&#160; Ascending bidirectional cursor requirements (in addition to ascending
        forward cursors and descending bidirectional cursors)</div><div class="table-contents"><table class="table" summary=" Ascending bidirectional cursor requirements (in addition to ascending
        forward cursors and descending bidirectional cursors)"><colgroup><col><col><col><col></colgroup><thead><tr><th>
                <p>
                  expression
                </p>
              </th><th>
                <p>
                  return type
                </p>
              </th><th>
                <p>
                  operational semantics
                </p>
              </th><th>
                <p>
                  assertion/note<br> pre/post-condition
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="literal">X::type</code>
                </p>
              </td><td>
                <p>
                  Convertible to <code class="literal">ascending_bidirectional_cursor_tag</code>
                </p>
              </td><td>
              </td><td>
                <p>
                  compile time
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"></div><div class="section" id="tree.cursor_requirements.ascending_random_access"><div class="titlepage"><div><div><h6 class="title">24.7.1.8.&#160;<a class="link" href="#tree.cursor_requirements.ascending_random_access" title="24.7.1.8.&#160;Ascending Random Access Cursor [ascending.random.access.cursors]">Ascending
      Random Access Cursor <span class="std_section_label">[ascending.random.access.cursors]</span></a></h6></div></div></div><p>
        A class type <code class="literal">X</code> satisfies the requirements of an ascending
        random access cursor if the following expressions are valid, as shown in
        Table 17, in addition to satisfying the requirements for ascending bidirectional
        cursors ([ascending.bidirectional.cursors]) and descending random access
        cursors ([descending.random.access.cursors]):
      </p><div class="table" id="tree.cursor_requirements.ascending_random_access.table17"><div class="table-title">Table&#160;17.&#160; Ascending random access cursor requirements (in addition to ascending
        bidirectional cursors and descending random access cursors)</div><div class="table-contents"><table class="table" summary=" Ascending random access cursor requirements (in addition to ascending
        bidirectional cursors and descending random access cursors)"><colgroup><col><col><col><col></colgroup><thead><tr><th>
                <p>
                  expression
                </p>
              </th><th>
                <p>
                  return type
                </p>
              </th><th>
                <p>
                  operational semantics
                </p>
              </th><th>
                <p>
                  assertion/note<br> pre/post-condition
                </p>
              </th></tr></thead><tbody><tr><td>
                <p>
                  <code class="literal">X::type</code>
                </p>
              </td><td>
                <p>
                  Convertible to <code class="literal">ascending_random_access_cursor_tag</code>
                </p>
              </td><td>
              </td><td>
                <p>
                  compile time
                </p>
              </td></tr></tbody></table></div></div><br class="table-break"></div></div><div class="section" id="tree.cursor_flavors"><div class="titlepage"><div><div><h5 class="title">24.7.2.&#160;<a class="link" href="#tree.cursor_flavors" title="24.7.2.&#160;Cursor flavors [cursor.flavors]">Cursor flavors <span class="std_section_label">[cursor.flavors]</span></a></h5></div></div></div><p>
      A cursor that satisfies at least the descending cursor requirements ([descending.cursors])
      can be either a <span class="emphasis"><em>plain cursor</em></span> or a <span class="emphasis"><em>multiway cursor</em></span>.
      If the expressions <code class="literal">a.begin()</code>, <code class="literal">a.cbegin()</code>,
      <code class="literal">a.end()</code> and <code class="literal">a.cend()</code> are valid for any
      internal cursor <code class="literal">a</code> of type <code class="literal">X</code>, except for
      past-the-end ones, <code class="literal">X</code> satisfies the <span class="emphasis"><em>plain cursor</em></span>
      requirements. If those expressions are valid for any internal cursor <span class="emphasis"><em>including</em></span>
      past-the-end ones, <code class="literal">X</code> satisfies the <span class="emphasis"><em>multiway cursor</em></span>
      requirements.
    </p></div><div class="section" id="tree.cursor_synopsis"><div class="titlepage"><div><div><h5 class="title">24.7.3.&#160;<a class="link" href="#tree.cursor_synopsis" title="24.7.3.&#160;Header &lt;cursor&gt; synopsis [cursor.synopsis]">Header <code class="literal">&lt;cursor&gt;</code>
    synopsis <span class="std_section_label">[cursor.synopsis]</span></a></h5></div></div></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="comment">// 24.7.4, cursor primitives</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_value</span><span class="special">;</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_reference</span><span class="special">;</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_const_reference</span><span class="special">;</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_pointer</span><span class="special">;</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_difference</span><span class="special">;</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_size</span><span class="special">;</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_category</span><span class="special">;</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Category</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Distance</span> <span class="special">=</span> <span class="identifier">ptrdiff_t</span><span class="special">,</span>
            <span class="keyword">class</span> <span class="identifier">Size</span> <span class="special">=</span> <span class="identifier">size_t</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Pointer</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">*,</span>
            <span class="keyword">class</span> <span class="identifier">Reference</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">&amp;&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor</span><span class="special">;</span>

  <span class="keyword">struct</span> <span class="identifier">cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">input_iterator_tag</span><span class="special">,</span> <span class="keyword">public</span> <span class="identifier">output_iterator_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">descending_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">cursor_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">descending_forward_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_cursor_tag</span><span class="special">,</span> <span class="keyword">public</span> <span class="identifier">forward_iterator_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">descending_bidirectional_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_cursor_tag</span><span class="special">,</span> <span class="keyword">public</span> <span class="identifier">bidirectional_iterator_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">descending_random_access_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_cursor_tag</span><span class="special">,</span> <span class="keyword">public</span> <span class="identifier">random_access_iterator_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">ascending_cursor_tag</span>
        <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_cursor_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">ascending_forward_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_forward_cursor_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">ascending_bidirectional_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_bidirectional_cursor_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">ascending_random_access_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_random_access_cursor_tag</span> <span class="special">{};</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" id="tree.cursor_primitives"><div class="titlepage"><div><div><h5 class="title">24.7.4.&#160;<a class="link" href="#tree.cursor_primitives" title="24.7.4.&#160;Cursor primitives [cursor.primitives]">Cursor primitives <span class="std_section_label">[cursor.primitives]</span></a></h5></div></div></div><p>
      To simplify the task of defining cursors, the library provides several classes
      and functions:
    </p><div class="section" id="tree.cursor_primitives.cursor_traits"><div class="titlepage"><div><div><h6 class="title">24.7.4.1.&#160;<a class="link" href="#tree.cursor_primitives.cursor_traits" title="24.7.4.1.&#160;Cursor traits [cursor.traits]">Cursor traits
      <span class="std_section_label">[cursor.traits]</span></a></h6></div></div></div><p>
        The following classes are required to be defined appropriately for a cursor
        of type <code class="literal">Cursor</code>:
      </p><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_value</span> <span class="special">{</span>
  <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Cursor</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_reference</span> <span class="special">{</span>
  <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Cursor</span><span class="special">::</span><span class="identifier">reference</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_const_reference</span> <span class="special">{</span>
  <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Cursor</span><span class="special">::</span><span class="identifier">const_reference</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_pointer</span> <span class="special">{</span>
  <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Cursor</span><span class="special">::</span><span class="identifier">pointer</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_difference</span> <span class="special">{</span>
  <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Cursor</span><span class="special">::</span><span class="identifier">difference_type</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_size</span> <span class="special">{</span>
  <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Cursor</span><span class="special">::</span><span class="identifier">size_type</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">cursor_category</span> <span class="special">{</span>
  <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">Cursor</span><span class="special">::</span><span class="identifier">cursor_category</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
</pre></div><div class="section" id="tree.cursor_primitives.cursor_basic"><div class="titlepage"><div><div><h6 class="title">24.7.4.2.&#160;<a class="link" href="#tree.cursor_primitives.cursor_basic" title="24.7.4.2.&#160;Basic cursor [cursor.basic]">Basic cursor <span class="std_section_label">[cursor.basic]</span></a></h6></div></div></div><p>
        The <code class="literal">cursor</code> template may be used as a base class to ease
        the definition of required types for new cursors.
      </p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Category</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Distance</span> <span class="special">=</span> <span class="identifier">ptrdiff_t</span><span class="special">,</span>
            <span class="keyword">class</span> <span class="identifier">Size</span> <span class="special">=</span> <span class="identifier">size_t</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Pointer</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">*,</span>
            <span class="keyword">class</span> <span class="identifier">Reference</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">&amp;&gt;</span>
  <span class="keyword">struct</span> <span class="identifier">cursor</span> <span class="special">{</span>
    <span class="keyword">typedef</span> <span class="identifier">Category</span>  <span class="identifier">cursor_category</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">T</span>         <span class="identifier">value_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">Distance</span>  <span class="identifier">difference_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">Size</span>      <span class="identifier">size_type</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">Pointer</span>   <span class="identifier">pointer</span><span class="special">;</span>
    <span class="keyword">typedef</span> <span class="identifier">Reference</span> <span class="identifier">reference</span><span class="special">;</span>
  <span class="special">};</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div><div class="section" id="tree.cursor_primitives.cursor_tags"><div class="titlepage"><div><div><h6 class="title">24.7.4.3.&#160;<a class="link" href="#tree.cursor_primitives.cursor_tags" title="24.7.4.3.&#160;Standard cursor tags [cursor.tags]">Standard cursor tags
      <span class="std_section_label">[cursor.tags]</span></a></h6></div></div></div><p>
        Cursor tags pick up the notion of iterator tags ([std.iterator.tags]) and
        extend them by adding information about a given cursor class' descending
        or ascending traversal capabilities ([cursor.requirements]). This yields
        the cursor tags <code class="literal">cursor_tag</code>, <code class="literal">descending_cursor_tag</code>,
        <code class="literal">descending_forward_cursor_tag</code>, <code class="literal">descending_bidirectional_cursor_tag</code>,
        <code class="literal">descending_random_access_cursor_tag</code>, <code class="literal">ascending_cursor_tag</code>,
        <code class="literal">ascending_forward_cursor_tag</code>, <code class="literal">ascending_bidirectional_cursor_tag</code>
        and <code class="literal">ascending_random_access_cursor_tag</code>. For every cursor
        of type <code class="literal">Cursor</code>, <code class="literal">cursor_category&lt;Cursor&gt;::type</code>
        must be defined to be the most specific category tag that describes the cursor's
        behavior.
      </p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>
  <span class="keyword">struct</span> <span class="identifier">cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">input_iterator_tag</span><span class="special">,</span> <span class="keyword">public</span> <span class="identifier">output_iterator_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">descending_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">cursor_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">descending_forward_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_cursor_tag</span><span class="special">,</span> <span class="keyword">public</span> <span class="identifier">forward_iterator_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">descending_bidirectional_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_cursor_tag</span><span class="special">,</span> <span class="keyword">public</span> <span class="identifier">bidirectional_iterator_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">descending_random_access_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_cursor_tag</span><span class="special">,</span> <span class="keyword">public</span> <span class="identifier">random_access_iterator_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">ascending_cursor_tag</span>
        <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_cursor_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">ascending_forward_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_forward_cursor_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">ascending_bidirectional_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_bidirectional_cursor_tag</span> <span class="special">{};</span>
  <span class="keyword">struct</span> <span class="identifier">ascending_random_access_cursor_tag</span>
    <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">descending_random_access_cursor_tag</span> <span class="special">{};</span>
<span class="special">}</span> <span class="comment">// namespace std</span>
</pre></div></div></div><div class="section std_section" id="order.iterators"><div class="titlepage"><div><div><h4 class="title">24.8.&#160;<a class="link" href="#order.iterators" title="24.8.&#160;Linear order traversal iterators [order.iterators]">Linear order traversal iterators <span class="std_section_label">[order.iterators]</span></a></h4></div></div></div><p>
    For linear traversal of hierarchies, the library offers a number of useful predefined
    iterators, namely for <code class="literal">preorder</code>, <code class="literal">postorder</code>
    and <code class="literal">inorder</code> traversal in namespaces named accordingly.
  </p><p>
    <span class="emphasis"><em>Preorder traversal</em></span> means that after a given element, first
    the subtree to its left, then the one to its right will be visited.
  </p><p>
    <span class="emphasis"><em>Postorder traversal</em></span> means that before a given element, first
    the subtree to its left, then the one to its right will be visited.
  </p><p>
    <span class="emphasis"><em>Inorder traversal</em></span> means that a given element will be visited
    after the subtree to its left and before the one to its right will be visited.
  </p><p>
    For each of the above kinds of traversal order, the library offers a kind of
    order traversal iterator adaptor template class whose template parameter is a
    bidirectional or random access (either ascending or descending) cursor class.
    Increment and decrement operations for these iterator adaptor classes are implemented
    to allow stepwise iteration according to the respective requirements.
  </p><div class="section" id="tree.order_iterator"><div class="titlepage"><div><div><h5 class="title">24.8.1.&#160;<a class="link" href="#tree.order_iterator" title="24.8.1.&#160;Class template iterator [order.iterator]">Class template <code class="literal">iterator</code>
    <span class="std_section_label">[order.iterator]</span></a></h5></div></div></div><div class="simplesect std_paragraph" id="idp9368816"><div class="titlepage"></div><p>
      In the following, the template class <code class="literal">iterator</code> and related
      operators only as in <code class="literal">namespace</code> <code class="literal">preorder</code>
      are shown. Note that template classes and operators of same name and interface
      must also be present in <code class="literal">namespace</code> <code class="literal">postorder</code>
      as well as in <code class="literal">namespace</code> <code class="literal">inorder</code>.
    </p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">std</span> <span class="special">{</span>

<span class="keyword">namespace</span> <span class="identifier">preorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span>
  <span class="keyword">class</span> <span class="identifier">iterator</span> <span class="special">:</span>
    <span class="keyword">public</span> <span class="identifier">iterator</span><span class="special">&lt;</span> <span class="comment">/* see Note A */</span><span class="special">,</span>
                    <span class="keyword">typename</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">,</span>
                    <span class="keyword">typename</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;::</span><span class="identifier">difference_type</span><span class="special">,</span>
                    <span class="keyword">typename</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;::</span><span class="identifier">pointer</span><span class="special">,</span>
                    <span class="keyword">typename</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;::</span><span class="identifier">reference</span><span class="special">&gt;</span> <span class="special">{</span>
  <span class="keyword">protected</span><span class="special">:</span>
    <span class="identifier">Cursor</span> <span class="identifier">current</span><span class="special">;</span>
  <span class="keyword">public</span><span class="special">:</span>
    <span class="keyword">typedef</span> <span class="identifier">Cursor</span> <span class="identifier">cursor_type</span><span class="special">;</span>
    <span class="identifier">iterator</span><span class="special">();</span>
    <span class="keyword">explicit</span> <span class="identifier">iterator</span><span class="special">(</span><span class="identifier">Cursor</span> <span class="identifier">x</span><span class="special">);</span>

    <span class="identifier">Cursor</span> <span class="identifier">base</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>         <span class="comment">// explicit</span>
    <span class="identifier">Reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="identifier">Pointer</span>   <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span>

    <span class="identifier">iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++();</span>
    <span class="identifier">iterator</span>  <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">);</span>
    <span class="identifier">iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">--();</span>
    <span class="identifier">iterator</span>  <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">int</span><span class="special">);</span>
  <span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>

<span class="special">}</span> <span class="comment">// namespace preorder</span>

<span class="special">}</span> <span class="comment">// namespace std</span>
</pre><p>
      <span class="emphasis"><em>Note A:</em></span> If <code class="computeroutput"><span class="keyword">typename</span>
      <span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;::</span><span class="identifier">iterator_category</span></code> is equivalent to <code class="literal">random_access_iterator_tag</code>,
      put in <code class="literal">bidirectional_iterator_tag</code>; otherwise put in <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;::</span><span class="identifier">iterator_category</span></code>.
    </p></div></div><div class="section" id="tree.order_iter_requirements"><div class="titlepage"><div><div><h5 class="title">24.8.2.&#160;<a class="link" href="#tree.order_iter_requirements" title="24.8.2.&#160;Linear order iterator requirements [order.iter.requirements]">Linear order <code class="literal">iterator</code>
    requirements <span class="std_section_label">[order.iter.requirements]</span></a></h5></div></div></div><p>
      The template parameter <code class="literal">Cursor</code> shall meet all the requirements
      of an Ascending Forward Cursor ([ascending.forward.cursors]). Additionally,
      for the template class and operators in <code class="literal">namespace</code> <code class="literal">inorder</code>,
      the template parameter <code class="literal">Cursor</code> must be a Multiway Cursor
      ([cursor.flavors]).
    </p><p>
      Additionally, <code class="literal">Cursor</code> shall meet the requirements of a Ascending
      Bidirectional Cursor ([ascending.bidirectional.cursors]) if the member <code class="literal">operator--</code>
      ([order.iter.op.eq]) is referenced in a way that requires instantiation (14.7.1).
    </p></div><div class="section" id="tree.order_iter_ops"><div class="titlepage"><div><div><h5 class="title">24.8.3.&#160;<a class="link" href="#tree.order_iter_ops" title="24.8.3.&#160;inorder::iterator operations [order.iter.ops]"><code class="literal">inorder::iterator</code>
    operations <span class="std_section_label">[order.iter.ops]</span></a></h5></div></div></div><div class="section" id="tree.order_iter_ops.order_iter_cons"><div class="titlepage"><div><div><h6 class="title">24.8.3.1.&#160;<a class="link" href="#tree.order_iter_ops.order_iter_cons" title="24.8.3.1.&#160;inorder::iterator constructor [order.iter.cons]"><code class="literal">inorder::iterator</code>
      constructor <span class="std_section_label">[order.iter.cons]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9485312"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">iterator</span><span class="special">(</span><span class="identifier">Cursor</span> <span class="identifier">x</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp9489888"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Effects:</em></span> Initializes <code class="literal">current</code> with
        <code class="literal">x</code>.
      </p></div></div><div class="section" id="tree.order_iter_ops.order_iter_conv"><div class="titlepage"><div><div><h6 class="title">24.8.3.2.&#160;<a class="link" href="#tree.order_iter_ops.order_iter_conv" title="24.8.3.2.&#160;Conversion [order.iter.conv]">Conversion <span class="std_section_label">[order.iter.conv]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9495088"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">Iterator</span> <span class="identifier">base</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span> <span class="comment">// explicit</span>
</pre></div><div class="simplesect std_specification" id="idp9499808"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">current</span></code>
      </p></div></div><div class="section" id="tree.order_iter_ops.order_iter_op_star"><div class="titlepage"><div><div><h6 class="title">24.8.3.3.&#160;<a class="link" href="#tree.order_iter_ops.order_iter_op_star" title="24.8.3.3.&#160;operator* [order.iter.op.star]"><code class="literal">operator*</code>
      <span class="std_section_label">[order.iter.op.star]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9505264"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">Reference</span> <span class="keyword">operator</span><span class="special">*()</span> <span class="keyword">const</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp9509344"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="identifier">current</span></code>
      </p></div></div><div class="section" id="tree.order_iter_ops.order_iter_op_ref"><div class="titlepage"><div><div><h6 class="title">24.8.3.4.&#160;<a class="link" href="#tree.order_iter_ops.order_iter_op_ref" title="24.8.3.4.&#160;operator-&gt; [order.iter.op.ref]"><code class="literal">operator-&gt;</code>
      <span class="std_section_label">[order.iter.op.ref]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9515328"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">Pointer</span> <span class="keyword">operator</span><span class="special">-&gt;()</span> <span class="keyword">const</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp9519440"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">&amp;(</span><span class="keyword">operator</span><span class="special">*())</span></code>
      </p></div></div><div class="section" id="tree.order_iter_ops.order_iter_op_inc"><div class="titlepage"><div><div><h6 class="title">24.8.3.5.&#160;<a class="link" href="#tree.order_iter_ops.order_iter_op_inc" title="24.8.3.5.&#160;operator++ [order.iter.op.inc]"><code class="literal">operator++</code>
      <span class="std_section_label">[order.iter.op.inc]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9525856"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++()</span> <span class="keyword">const</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp9530464"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Effects:</em></span> Sets <code class="literal">current</code> to the next
        cursor in the given order.
      </p></div><div class="simplesect std_specification" id="idp9532608"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
      </p></div><div class="simplesect std_definition" id="idp9535632"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">iterator</span> <span class="keyword">operator</span><span class="special">++(</span><span class="keyword">int</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp9540752"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Effects:</em></span>
      </p><pre class="programlisting"><span class="identifier">iterator</span> <span class="identifier">tmp</span> <span class="special">=</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="keyword">this</span><span class="special">-&gt;</span><span class="keyword">operator</span><span class="special">++();</span>
<span class="keyword">return</span> <span class="identifier">tmp</span><span class="special">;</span>
</pre></div></div><div class="section" id="tree.order_iter_ops.order_iter_op_dec"><div class="titlepage"><div><div><h6 class="title">24.8.3.6.&#160;<a class="link" href="#tree.order_iter_ops.order_iter_op_dec" title="24.8.3.6.&#160;operator-- [order.iter.op.dec]"><code class="literal">operator--</code>
      <span class="std_section_label">[order.iter.op.dec]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9553184"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">iterator</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">--()</span> <span class="keyword">const</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp9557792"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Effects:</em></span> Sets <code class="literal">current</code> to the previous
        cursor in the given order.
      </p></div><div class="simplesect std_specification" id="idp9559936"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
      </p></div><div class="simplesect std_definition" id="idp9562960"><div class="titlepage"></div><pre class="programlisting"><span class="identifier">iterator</span> <span class="keyword">operator</span><span class="special">--(</span><span class="keyword">int</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
</pre></div><div class="simplesect std_specification" id="idp9568080"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Effects:</em></span>
      </p><pre class="programlisting"><span class="identifier">iterator</span> <span class="identifier">tmp</span> <span class="special">=</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="keyword">this</span><span class="special">-&gt;</span><span class="keyword">operator</span><span class="special">--();</span>
<span class="keyword">return</span> <span class="identifier">tmp</span><span class="special">;</span>
</pre></div></div><div class="section" id="tree.order_iter_ops.order_iter_op_eq"><div class="titlepage"><div><div><h6 class="title">24.8.3.7.&#160;<a class="link" href="#tree.order_iter_ops.order_iter_op_eq" title="24.8.3.7.&#160;operator== [order.iter.op.eq]"><code class="literal">operator==</code>
      <span class="std_section_label">[order.iter.op.eq]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9580512"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==(</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp9594272"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">current</span> <span class="special">==</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">current</span></code>
      </p></div></div><div class="section" id="tree.order_iter_ops.order_iter_op_ne"><div class="titlepage"><div><div><h6 class="title">24.8.3.8.&#160;<a class="link" href="#tree.order_iter_ops.order_iter_op_ne" title="24.8.3.8.&#160;operator!= [order.iter.op.ne]"><code class="literal">operator!=</code>
      <span class="std_section_label">[order.iter.op.ne]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9602976"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Cursor</span><span class="special">&gt;</span>
  <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">!=(</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">x</span><span class="special">,</span>
    <span class="keyword">const</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">Cursor</span><span class="special">&gt;&amp;</span> <span class="identifier">y</span><span class="special">);</span>
</pre></div><div class="simplesect std_specification" id="idp9616736"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">current</span> <span class="special">!=</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">current</span></code>
      </p></div></div></div></div></div><div class="section std_section" id="tree.proposal.algorithms"><div class="titlepage"><div><div><h3 class="title">25.&#160;<a class="link" href="#tree.proposal.algorithms" title="25.&#160;Algorithms library [algorithms]">Algorithms
  library <span class="std_section_label">[algorithms]</span></a></h3></div></div></div><div class="note"><h3 class="title">Note</h3><p>
      Append to paragraph 2, <em class="replaceable"><code>Header <code class="literal">&lt;iterator&gt;</code>
      synopsis</code></em>, after <code class="computeroutput"><span class="comment">// subclause 25.2,
      non-modifying sequence operations</span></code>.
    </p></div><pre class="programlisting"><span class="comment">// subclause 25.3, non-modifying hierarchy operations</span>
<span class="keyword">namespace</span> <span class="identifier">preorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">Hierarchy</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cbegin</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">Hierarchy</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cend</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace preorder</span>

<span class="keyword">namespace</span> <span class="identifier">postorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">Hierarchy</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cbegin</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">Hierarchy</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cend</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace postorder</span>

<span class="keyword">namespace</span> <span class="identifier">inorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cbegin</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>

  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cend</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace inorder</span>
</pre><div class="note"><h3 class="title">Note</h3><p>
      <code class="literal">[c]rbegin(...)</code> and <code class="literal">[c]rend(..)</code> are not
      provided as they can be achieved via <code class="literal">reverse_iterator({[c]begin(...)|[c]end(...)})</code>
      (which also defines requirements when this is possible)
    </p></div><div class="note"><h3 class="title">Note</h3><p>
      Change paragraph 3 to read:
    </p></div><p>
    All of the algorithms are separated from the particular implementations of data
    structures and are parameterized by iterator or hierarchy types. Because of this,
    they can work with program-defined data structures, as long as these data structures
    have iterator or cursor types satisfying the assumptions on the algorithms.
  </p><div class="note"><h3 class="title">Note</h3><p>
      Append to paragraph 5:
    </p></div><p>
    If an algorithm's template parameter is <code class="literal">Hierarchy</code>, the actual
    template argument shall satisfy the requirements of a hierarchy ([hierarchy.req]).
    If an algorithm's template parameter is <code class="literal">MultiwayHierarchy</code>,
    the actual template argument shall satisfy the requirements of a multiway hierarchy
    ([hierarchy.multiway]).
  </p><div class="note"><h3 class="title">Note</h3><p>
      Insert after section 25.2 Non-modifying sequence operations [alg.nonmodifying]
    </p></div><div class="section std_section" id="alg.hierarchy"><div class="titlepage"><div><div><h4 class="title">25.3.&#160;<a class="link" href="#alg.hierarchy" title="25.3.&#160;Non-modifying hierarchy algorithms [alg.hierarchy]">Non-modifying hierarchy algorithms <span class="std_section_label">[alg.hierarchy]</span></a></h4></div></div></div><div class="section" id="tree.alg_hier_preorder"><div class="titlepage"><div><div><h5 class="title">25.3.1.&#160;<a class="link" href="#tree.alg_hier_preorder" title="25.3.1.&#160;Non-modifying hierarchy preorder range algorithms [alg.hier.preorder]">Non-modifying hierarchy preorder
    range algorithms <span class="std_section_label">[alg.hier.preorder]</span></a></h5></div></div></div><div class="section" id="tree.alg_hier_preorder.alg_hier_pre_begin"><div class="titlepage"><div><div><h6 class="title">25.3.1.1.&#160;<a class="link" href="#tree.alg_hier_preorder.alg_hier_pre_begin" title="25.3.1.1.&#160;Preorder begin [alg.hier.pre.begin]">Preorder begin
      <span class="std_section_label">[alg.hier.pre.begin]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9843584"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">preorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">Hierarchy</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cbegin</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace preorder</span>
</pre></div><div class="simplesect std_specification" id="idp9879360"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> An iterator pointing to the first element of
        <code class="literal">h</code> in preorder.
      </p></div><div class="simplesect std_specification" id="idp9881504"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Complexity:</em></span> constant
      </p></div></div><div class="section" id="tree.alg_hier_preorder.alg_hier_pre_end"><div class="titlepage"><div><div><h6 class="title">25.3.1.2.&#160;<a class="link" href="#tree.alg_hier_preorder.alg_hier_pre_end" title="25.3.1.2.&#160;Preorder end [alg.hier.pre.end]">Preorder end
      <span class="std_section_label">[alg.hier.pre.end]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9885344"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">preorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">Hierarchy</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cend</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace preorder</span>
</pre></div><div class="simplesect std_specification" id="idp9921088"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> An iterator pointing one position past the
        last element of <code class="literal">h</code> in preorder.
      </p></div><div class="simplesect std_specification" id="idp9923248"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Complexity:</em></span> linear
      </p></div></div></div><div class="section" id="tree.alg_hier_postorder"><div class="titlepage"><div><div><h5 class="title">25.3.2.&#160;<a class="link" href="#tree.alg_hier_postorder" title="25.3.2.&#160;Non-modifying hierarchy postorder range algorithms [alg.hier.postorder]">Non-modifying hierarchy postorder
    range algorithms <span class="std_section_label">[alg.hier.postorder]</span></a></h5></div></div></div><div class="section" id="tree.alg_hier_postorder.alg_hier_post_begin"><div class="titlepage"><div><div><h6 class="title">25.3.2.1.&#160;<a class="link" href="#tree.alg_hier_postorder.alg_hier_post_begin" title="25.3.2.1.&#160;Postorder begin [alg.hier.post.begin]">Postorder
      begin <span class="std_section_label">[alg.hier.post.begin]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9929440"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">postorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">Hierarchy</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cbegin</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace postorder</span>
</pre></div><div class="simplesect std_specification" id="idp9965216"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> An iterator pointing to the first element of
        <code class="literal">h</code> in postorder.
      </p></div><div class="simplesect std_specification" id="idp9967360"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Complexity:</em></span> linear
      </p></div></div><div class="section" id="tree.alg_hier_postorder.alg_hier_post_end"><div class="titlepage"><div><div><h6 class="title">25.3.2.2.&#160;<a class="link" href="#tree.alg_hier_postorder.alg_hier_post_end" title="25.3.2.2.&#160;Postorder end [alg.hier.post.end]">Postorder
      end <span class="std_section_label">[alg.hier.post.end]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp9971184"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">postorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">Hierarchy</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Hierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Hierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cend</span><span class="special">(</span><span class="identifier">Hierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">h</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace postorder</span>
</pre></div><div class="simplesect std_specification" id="idp10006928"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> An iterator pointing one position past the
        last element of <code class="literal">h</code> in postorder.
      </p></div><div class="simplesect std_specification" id="idp10009088"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Complexity:</em></span> constant
      </p></div></div></div><div class="section" id="tree.alg_hier_inorder"><div class="titlepage"><div><div><h5 class="title">25.3.3.&#160;<a class="link" href="#tree.alg_hier_inorder" title="25.3.3.&#160;Non-modifying hierarchy inorder range algorithms [alg.hier.inorder]">Non-modifying hierarchy inorder
    range algorithms <span class="std_section_label">[alg.hier.inorder]</span></a></h5></div></div></div><div class="section" id="tree.alg_hier_inorder.alg_hier_in_begin"><div class="titlepage"><div><div><h6 class="title">25.3.3.1.&#160;<a class="link" href="#tree.alg_hier_inorder.alg_hier_in_begin" title="25.3.3.1.&#160;Inorder begin [alg.hier.in.begin]">Inorder begin
      <span class="std_section_label">[alg.hier.in.begin]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp10015392"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">inorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">begin</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cbegin</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace inorder</span>
</pre></div><div class="simplesect std_specification" id="idp10051312"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> An iterator pointing to the first element of
        <code class="literal">h</code> in inorder.
      </p></div><div class="simplesect std_specification" id="idp10053456"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Complexity:</em></span> linear
      </p></div></div><div class="section" id="tree.alg_hier_inorder.alg_hier_in_end"><div class="titlepage"><div><div><h6 class="title">25.3.3.2.&#160;<a class="link" href="#tree.alg_hier_inorder.alg_hier_in_end" title="25.3.3.2.&#160;Inorder end [alg.hier.in.end]">Inorder end <span class="std_section_label">[alg.hier.in.end]</span></a></h6></div></div></div><div class="simplesect std_definition" id="idp10057264"><div class="titlepage"></div><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">inorder</span> <span class="special">{</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">end</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
  <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">MultiwayHierarchy</span><span class="special">&gt;</span>
    <span class="identifier">iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">MultiwayHierarchy</span><span class="special">::</span><span class="identifier">const_cursor</span><span class="special">&gt;</span>
      <span class="identifier">cend</span><span class="special">(</span><span class="identifier">MultiwayHierarchy</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">m</span><span class="special">);</span>
<span class="special">}</span> <span class="comment">// namespace inorder</span>
</pre></div><div class="simplesect std_specification" id="idp10093152"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Returns:</em></span> An iterator pointing one position past the
        last element of <code class="literal">h</code> in inorder.
      </p></div><div class="simplesect std_specification" id="idp10095312"><div class="titlepage"></div><p>
        <span class="emphasis"><em>Complexity:</em></span> linear
      </p></div></div></div></div></div></div><div class="section" id="tree.references"><div class="titlepage"><div><div><h2 class="title" style="clear: both">3.&#160;<a class="link" href="#tree.references" title="3.&#160;References">References</a></h2></div></div></div><div class="variablelist"><div class="variablelist-title">References</div><dl class="variablelist"><dt><span class="term"> <span id="ref.austern"></span>austern</span></dt><dd><p>
            Austern, Matthew H.; Stroustrup, Bjarne; Thorup, Mikkel; Wilikinson,
            John. <span class="emphasis"><em>Untangling the Balancing and Searching of Balanced Binary
            Search Trees</em></span>, Software: Practice and Experience 33(13): 1273-1298
            (2003) Electronic Appendix: <a href="http://www.stroustrup.com/tree-appendix.pdf" target="_top">http://www.stroustrup.com/tree-appendix.pdf</a>
          </p></dd><dt><span class="term"> <span id="ref.cormen"></span>cormen</span></dt><dd><p>
            Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford.
            <span class="emphasis"><em>Introduction to Algorithms</em></span>. Second Edition (MIT
            Press, 2001)
          </p></dd><dt><span class="term"> <span id="ref.dreizin"></span>dreizin</span></dt><dd><p>
            Dreizin, Vladimir; Kosnik, Benjamin; Tavory, Ami. <span class="emphasis"><em>Policy-Based
            Data Structures</em></span>, <a href="http://gcc.gnu.org/onlinedocs/libstdc++/ext/pb_ds/" target="_top">http://gcc.gnu.org/onlinedocs/libstdc++/ext/pb_ds/</a>
          </p></dd><dt><span class="term"> <span id="ref.ekman"></span>ekman</span></dt><dd><p>
            Ekman, Rasmus. <span class="emphasis"><em>Structured Associative Containers</em></span>,
            <a href="http://www.abc.se/~re/code/tst/tst_docs/index.html" target="_top">http://www.abc.se/~re/code/tst/tst_docs/index.html</a>
          </p></dd><dt><span class="term"> <span id="ref.gottschlich"></span>gottschlich</span></dt><dd><p>
            Gottschlich, Justin. <span class="emphasis"><em>C++ Trees</em></span>, <a href="http://www.gamedev.net/page/resources/_/technical/general-programming/c-trees-part-1-r2192" target="_top">http://www.gamedev.net/page/resources/_/technical/general-programming/c-trees-part-1-r2192</a>
            and <a href="http://www.gamedev.net/page/resources/_/technical/general-programming/c-trees-part-2-basic-coretreefun-r2233" target="_top">http://www.gamedev.net/page/resources/_/technical/general-programming/c-trees-part-2-basic-coretreefun-r2233</a>
          </p></dd><dt><span class="term"> <span id="ref.haas"></span>haas</span></dt><dd><p>
            Haas, Mitchell. <span class="emphasis"><em>Tree Container Library</em></span>, <a href="http://www.datasoftsolutions.net/tree_container_library/overview.php" target="_top">http://www.datasoftsolutions.net/tree_container_library/overview.php</a>
          </p></dd><dt><span class="term"> <span id="ref.karas"></span>karas</span></dt><dd><p>
            Karas, Walt. <span class="emphasis"><em>C++ AVL Tree Template</em></span>, <a href="http://wkaras.webs.com/gen_cpp/avl_tree.html" target="_top">http://wkaras.webs.com/gen_cpp/avl_tree.html</a>
          </p></dd><dt><span class="term"> <span id="ref.knuth97"></span>knuth97</span></dt><dd><p>
            Knuth, Donald E. <span class="emphasis"><em>The Art of Computer Programming</em></span>.
            Volume 1: Fundamental Algorithms. Third Edition (Reading, Massachusetts:
            Addison-Wesley, 1997)
          </p></dd><dt><span class="term"> <span id="ref.knuth98"></span>knuth98</span></dt><dd><p>
            Knuth, Donald E. <span class="emphasis"><em>The Art of Computer Programming</em></span>.
            Volume 3: Sorting and Searching. Second Edition (Reading, Massachusetts:
            Addison-Wesley, 1998)
          </p></dd><dt><span class="term"> <span id="ref.parent"></span>parent</span></dt><dd><p>
            Parent, Sean et al. <span class="emphasis"><em>forest</em></span>, <a href="http://stlab.adobe.com/group__forest__related.html" target="_top">http://stlab.adobe.com/group__forest__related.html</a>
          </p></dd><dt><span class="term"> <span id="ref.peeters"></span>peeters</span></dt><dd><p>
            Peeters, Kasper. <span class="emphasis"><em>tree.hh: an STL-like C++ tree class</em></span>,
            <a href="http://tree.phi-sci.com/" target="_top">http://tree.phi-sci.com/</a>
          </p></dd><dt><span class="term"> <span id="ref.rivera"></span>rivera</span></dt><dd><p>
            Rivera, Ren&#233;. <span class="emphasis"><em>rank_tree.h</em></span>, <a href="http://redshift-software.com/sites/redshift-software.com/files/grafik/rank_tree.h" target="_top">http://redshift-software.com/sites/redshift-software.com/files/grafik/rank_tree.h</a>
          </p></dd></dl></div></div></div></body></html>
