
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>Working Draft Technical Specification - URI</title>
    
    <style type="text/css">
.highlight .hll { background-color: #ffffcc }
.highlight  { background: #eeffcc; }
.highlight .c { color: #408090; font-style: italic } /* Comment */
.highlight .err { border: 1px solid #FF0000 } /* Error */
.highlight .k { color: #007020; font-weight: bold } /* Keyword */
.highlight .o { color: #666666 } /* Operator */
.highlight .cm { color: #408090; font-style: italic } /* Comment.Multiline */
.highlight .cp { color: #007020 } /* Comment.Preproc */
.highlight .c1 { color: #408090; font-style: italic } /* Comment.Single */
.highlight .cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #A00000 } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #FF0000 } /* Generic.Error */
.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
.highlight .gi { color: #00A000 } /* Generic.Inserted */
.highlight .go { color: #303030 } /* Generic.Output */
.highlight .gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
.highlight .gt { color: #0040D0 } /* Generic.Traceback */
.highlight .kc { color: #007020; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #007020; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #007020 } /* Keyword.Pseudo */
.highlight .kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #902000 } /* Keyword.Type */
.highlight .m { color: #208050 } /* Literal.Number */
.highlight .s { color: #4070a0 } /* Literal.String */
.highlight .na { color: #4070a0 } /* Name.Attribute */
.highlight .nb { color: #007020 } /* Name.Builtin */
.highlight .nc { color: #0e84b5; font-weight: bold } /* Name.Class */
.highlight .no { color: #60add5 } /* Name.Constant */
.highlight .nd { color: #555555; font-weight: bold } /* Name.Decorator */
.highlight .ni { color: #d55537; font-weight: bold } /* Name.Entity */
.highlight .ne { color: #007020 } /* Name.Exception */
.highlight .nf { color: #06287e } /* Name.Function */
.highlight .nl { color: #002070; font-weight: bold } /* Name.Label */
.highlight .nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
.highlight .nt { color: #062873; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #bb60d5 } /* Name.Variable */
.highlight .ow { color: #007020; font-weight: bold } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mf { color: #208050 } /* Literal.Number.Float */
.highlight .mh { color: #208050 } /* Literal.Number.Hex */
.highlight .mi { color: #208050 } /* Literal.Number.Integer */
.highlight .mo { color: #208050 } /* Literal.Number.Oct */
.highlight .sb { color: #4070a0 } /* Literal.String.Backtick */
.highlight .sc { color: #4070a0 } /* Literal.String.Char */
.highlight .sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
.highlight .s2 { color: #4070a0 } /* Literal.String.Double */
.highlight .se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
.highlight .sh { color: #4070a0 } /* Literal.String.Heredoc */
.highlight .si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
.highlight .sx { color: #c65d09 } /* Literal.String.Other */
.highlight .sr { color: #235388 } /* Literal.String.Regex */
.highlight .s1 { color: #4070a0 } /* Literal.String.Single */
.highlight .ss { color: #517918 } /* Literal.String.Symbol */
.highlight .bp { color: #007020 } /* Name.Builtin.Pseudo */
.highlight .vc { color: #bb60d5 } /* Name.Variable.Class */
.highlight .vg { color: #bb60d5 } /* Name.Variable.Global */
.highlight .vi { color: #bb60d5 } /* Name.Variable.Instance */
.highlight .il { color: #208050 } /* Literal.Number.Integer.Long */

body {
   font-family: sans-serif;
   margin: 1em;
   max-width : 8.5in;
}

/* -- main layout ----------------------------------------------------------- */

div.clearer {
    clear: both;
}

img {
    border: 0;
}

/* -- search page ----------------------------------------------------------- */

ul.search {
    margin: 10px 0 0 20px;
    padding: 0;
}

ul.search li {
    padding: 5px 0 5px 20px;
    background-image: url(file.png);
    background-repeat: no-repeat;
    background-position: 0 7px;
}

ul.search li a {
    font-weight: bold;
}

ul.search li div.context {
    color: #888;
    margin: 2px 0 0 30px;
    text-align: left;
}

ul.keywordmatches li.goodmatch a {
    font-weight: bold;
}

/* -- index page ------------------------------------------------------------ */

table.contentstable {
    width: 90%;
}

table.contentstable p.biglink {
    line-height: 150%;
}

a.biglink {
    font-size: 1.3em;
}

span.linkdescr {
    font-style: italic;
    padding-top: 5px;
    font-size: 90%;
}

/* -- general index --------------------------------------------------------- */

table.indextable {
    width: 100%;
}

table.indextable td {
    text-align: left;
    vertical-align: top;
}

table.indextable dl, table.indextable dd {
    margin-top: 0;
    margin-bottom: 0;
}

table.indextable tr.pcap {
    height: 10px;
}

table.indextable tr.cap {
    margin-top: 10px;
    background-color: #f2f2f2;
}

img.toggler {
    margin-right: 3px;
    margin-top: 3px;
    cursor: pointer;
}

div.modindex-jumpbox {
    border-top: 1px solid #ddd;
    border-bottom: 1px solid #ddd;
    margin: 1em 0 1em 0;
    padding: 0.4em;
}

div.genindex-jumpbox {
    border-top: 1px solid #ddd;
    border-bottom: 1px solid #ddd;
    margin: 1em 0 1em 0;
    padding: 0.4em;
}

/* -- general body styles --------------------------------------------------- */

a.headerlink {
    visibility: hidden;
}

h1:hover > a.headerlink,
h2:hover > a.headerlink,
h3:hover > a.headerlink,
h4:hover > a.headerlink,
h5:hover > a.headerlink,
h6:hover > a.headerlink,
dt:hover > a.headerlink {
    visibility: visible;
}

div.body p.caption {
    text-align: inherit;
}

div.body td {
    text-align: left;
}

.field-list ul {
    padding-left: 1em;
}

.first {
    margin-top: 0 !important;
}

p.rubric {
    margin-top: 30px;
    font-weight: bold;
}

img.align-left, .figure.align-left, object.align-left {
    clear: left;
    float: left;
    margin-right: 1em;
}

img.align-right, .figure.align-right, object.align-right {
    clear: right;
    float: right;
    margin-left: 1em;
}

img.align-center, .figure.align-center, object.align-center {
  display: block;
  margin-left: auto;
  margin-right: auto;
}

.align-left {
    text-align: left;
}

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

.align-right {
    text-align: right;
}

/* -- topics ---------------------------------------------------------------- */

div.topic {
    border: 1px solid #ccc;
    padding: 7px 7px 0 7px;
    margin: 10px 0 10px 0;
}

p.topic-title {
    font-size: 1.1em;
    font-weight: bold;
    margin-top: 10px;
}

/* -- admonitions ----------------------------------------------------------- */

div.admonition {
    margin-top: 10px;
    margin-bottom: 10px;
    padding: 7px;
    background-color: yellow;
}

div.admonition dt {
    font-weight: bold;
}

div.admonition dl {
    margin-bottom: 0;
}

p.admonition-title {
    margin: 0px 10px 5px 0px;
    font-weight: bold;
}

div.body p.centered {
    text-align: center;
    margin-top: 25px;
}

/* -- tables ---------------------------------------------------------------- */

table.docutils {
    border: 0;
    border-collapse: collapse;
}

table.docutils td, table.docutils th {
    padding: 1px 8px 1px 5px;
    border-top: 0;
    border-left: 0;
    border-right: 0;
    border-bottom: 1px solid #aaa;
}

table.field-list td, table.field-list th {
    border: 0 !important;
}

table.footnote td, table.footnote th {
    border: 0 !important;
}

th {
    text-align: left;
    padding-right: 5px;
}

table.citation {
    border-left: solid 1px gray;
    margin-left: 1px;
}

table.citation td {
    border-bottom: none;
}

/* -- other body styles ----------------------------------------------------- */

ol.arabic {
    list-style: decimal;
}

ol.loweralpha {
    list-style: lower-alpha;
}

ol.upperalpha {
    list-style: upper-alpha;
}

ol.lowerroman {
    list-style: lower-roman;
}

ol.upperroman {
    list-style: upper-roman;
}

dl {
    margin-bottom: 15px;
}

dd p {
    margin-top: 0px;
}

dd ul, dd table {
    margin-bottom: 10px;
}

dd {
    margin-top: 3px;
    margin-bottom: 10px;
    margin-left: 30px;
}

dt:target, .highlighted {
    background-color: #fbe54e;
}

dl.glossary dt {
    font-weight: bold;
    font-size: 1.1em;
}

.field-list ul {
    margin: 0;
    padding-left: 1em;
}

.field-list p {
    margin: 0;
}

.refcount {
    color: #060;
}

.optional {
    font-size: 1.3em;
}

.versionmodified {
    font-style: italic;
}

.system-message {
    background-color: #fda;
    padding: 5px;
    border: 3px solid red;
}

.footnote:target  {
    background-color: #ffa;
}

.line-block {
    display: block;
    margin-top: 1em;
    margin-bottom: 1em;
}

.line-block .line-block {
    margin-top: 0;
    margin-bottom: 0;
    margin-left: 1.5em;
}

.guilabel, .menuselection {
    font-family: sans-serif;
}

.accelerator {
    text-decoration: underline;
}

.classifier {
    font-style: oblique;
}

abbr, acronym {
    border-bottom: dotted 1px;
    cursor: help;
}

/* -- code displays --------------------------------------------------------- */

pre {
    overflow: auto;
    overflow-y: hidden;  /* fixes display issues on Chrome browsers */
}

td.linenos pre {
    padding: 5px 0px;
    border: 0;
    background-color: transparent;
    color: #aaa;
}

table.highlighttable {
    margin-left: 0.5em;
}

table.highlighttable td {
    padding: 0 0.5em 0 0.5em;
}

tt.descname {
    background-color: transparent;
    font-weight: bold;
    font-size: 1.2em;
}

tt.descclassname {
    background-color: transparent;
}

tt.xref, a tt {
    background-color: transparent;
    font-weight: bold;
}

h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt {
    background-color: transparent;
}

.viewcode-link {
    float: right;
}

.viewcode-back {
    float: right;
    font-family: sans-serif;
}

div.viewcode-block:target {
    margin: -1px -10px;
    padding: 0 10px;
}

/* -- math display ---------------------------------------------------------- */

img.math {
    vertical-align: middle;
}

div.body div.math p {
    text-align: center;
}

span.eqno {
    float: right;
}

/* -- printout stylesheet --------------------------------------------------- */

@media print {
    div.document,
    div.documentwrapper,
    div.bodywrapper {
        margin: 0 !important;
        width: 100%;
    }

    div.related,
    div.footer,
    #top-link {
        display: none;
    }
}
    </style>
    <link rel="top" title="None" href="index.html#document-index" /> 
  </head>
  <body>

    <div class="document">
      <div class="documentwrapper">
          <div class="body">
            
  <span class="target" id="index"></span><div class="section" id="working-draft-technical-specification-uri">
<h1>Working Draft Technical Specification - URI<a class="headerlink" href="#working-draft-technical-specification-uri" title="Permalink to this headline">¶</a></h1>
<div class="line-block">
<div class="line"><strong>Document Number</strong>: N3792</div>
<div class="line"><strong>Revises</strong>: N3720</div>
<div class="line"><strong>Date</strong>: 2013-10-11</div>
<div class="line"><strong>Authors</strong>: Glyn Matthews &lt;<a class="reference external" href="mailto:glyn&#46;matthews&#37;&#52;&#48;gmail&#46;com">glyn<span>&#46;</span>matthews<span>&#64;</span>gmail<span>&#46;</span>com</a>&gt;, Dean Michael Berris &lt;<a class="reference external" href="mailto:dberris&#37;&#52;&#48;google&#46;com">dberris<span>&#64;</span>google<span>&#46;</span>com</a>&gt;</div>
</div>
<div class="toctree-wrapper compound">
<span id="document-introduction"></span><div class="section" id="introduction">
<span id="id1"></span><h2>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h2>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">Notes highlighted in yellow are comments on the working draft and
are not intended for the actual TS.</p>
</div>
</div>
<div class="section" id="revisions-to-n3720">
<h2>Revisions to N3720<a class="headerlink" href="#revisions-to-n3720" title="Permalink to this headline">¶</a></h2>
<ol class="arabic simple">
<li>Added an &#8220;Error Reporting&#8221; section.</li>
<li>Renamed &#8220;Alloc&#8221; to &#8220;Allocator&#8221; to bring it more in to line with the
standard.</li>
<li>Renamed <tt class="docutils literal"><span class="pre">uri::make_reference</span></tt> to <tt class="docutils literal"><span class="pre">uri::make_relative</span></tt>.</li>
<li>Renamed <tt class="docutils literal"><span class="pre">uri_comparison_level</span></tt> to <tt class="docutils literal"><span class="pre">uri_normalization_level</span></tt>.</li>
<li>Added sections for <tt class="docutils literal"><span class="pre">uri_error</span></tt> and <tt class="docutils literal"><span class="pre">uri_normalization_level</span></tt>.</li>
<li>Added a <tt class="docutils literal"><span class="pre">base_uri_error</span></tt> that can be thrown by the <tt class="docutils literal"><span class="pre">resolve</span></tt>
and <tt class="docutils literal"><span class="pre">make_relative</span></tt> member functions in the event that the base
URI is not valid.</li>
<li>Improved documentation of URI resolution in the Terms and
Definition section and in the description of the <tt class="docutils literal"><span class="pre">resolve</span></tt> member
functions.</li>
<li>Using the standard hash specialization instead of <tt class="docutils literal"><span class="pre">hash_value</span></tt>.</li>
<li>Allowed the <tt class="docutils literal"><span class="pre">Source</span></tt> template argument to be
<tt class="docutils literal"><span class="pre">basic_string_view&lt;CharT,</span> <span class="pre">CharTraits&gt;</span></tt></li>
<li><tt class="docutils literal"><span class="pre">uri_builder</span></tt> now allows copy and move.</li>
<li>All constructors that accept an argument of type <tt class="docutils literal"><span class="pre">Source</span></tt> now
also take <tt class="docutils literal"><span class="pre">InputIterator</span></tt> overloads.</li>
<li>Fixed minor typographical errors.</li>
</ol>
</div>
<span id="document-scope"></span><div class="section" id="scope-uri-scope">
<span id="scope"></span><h2>1 Scope [uri.scope]<a class="headerlink" href="#scope-uri-scope" title="Permalink to this headline">¶</a></h2>
<p>The scope of this Technical Specification will include a single
<tt class="docutils literal"><span class="pre">std::experimental::uri</span></tt> type, specifications about how the are
intended to be processed and extended, including some additional
helper types and functions. It will include a
<tt class="docutils literal"><span class="pre">std::experimental::uri_builder</span></tt> type to build a URI from its
components. Finally, it will include types and functions for percent
encoding, URI references, reference resolution and URI normalization
and comparison.</p>
</div>
<span id="document-conformance"></span><div class="section" id="conformance-uri-conformance">
<span id="conformance"></span><h2>2 Conformance [uri.conformance]<a class="headerlink" href="#conformance-uri-conformance" title="Permalink to this headline">¶</a></h2>
<div class="section" id="generic-syntax-uri-conformance-generic-syntax">
<h3>2.1 Generic syntax [uri.conformance.generic-syntax]<a class="headerlink" href="#generic-syntax-uri-conformance-generic-syntax" title="Permalink to this headline">¶</a></h3>
<p>The generic syntax of a URI is defined in IETF RFC 3986. section 3.</p>
<p>All URIs are of the form:</p>
<div class="highlight-python"><pre>scheme ":" "hierarchical part" [ "?" query ] [ "#" fragment ]</pre>
</div>
<p>The scheme is used to identify the specification needed to parse the
rest of the URI. A generic syntax parser can parse any URI into its
main parts. The scheme can then be used to identify whether further
scheme-specific parsing can be performed.</p>
<p>The hierarchical part refers to the part of the URI that holds
identification information that is hierarchical in nature. This may
contain an authority (always prefixed with a double slash (&#8220;//&#8221;))
and/or a path. The path part is required, thought it may be empty. The
authority part holds an optional user info part, ending with an at
sign (&#8220;&#64;&#8221;); a host identifier and an optional port number, preceded by
a colon (&#8221;:&#8221;). The host may be an IP address or domain name. The
normative reference for IPv6 addresses is IETF RFC 2732.</p>
<p>The query is an optional part following a question mark (&#8221;?&#8221;) that
contains information that is not hierarchical.</p>
<p>Finally, the fragment is an optional part, prefixed by a hash symbol
(&#8220;#&#8221;) that is used to identify secondary sources.</p>
<p>IETF RFC 3987 specifies a new protocol element, the Internationalized
Resource Identifier (IRI). The IRI complements a URI, and extends it
to allow unicode characters. The syntax of an IRI is specified in IETF
RFC 3987, section 2.</p>
<p>IETF RFC 6874 specifies scoped IDs in IPv6 addresses. The syntax is
specified in IETF RFC 6874, section 2.</p>
</div>
<div class="section" id="uri-normalization-and-comparison-uri-conformance-uri-normalization-and-comparison">
<h3>2.2 URI Normalization and Comparison [uri.conformance.uri-normalization-and-comparison]<a class="headerlink" href="#uri-normalization-and-comparison-uri-conformance-uri-normalization-and-comparison" title="Permalink to this headline">¶</a></h3>
<p>The rules for URI normalization are specified in IETF RFC 3986,
section 6 and IETF RFC 3987, section 5.</p>
</div>
<div class="section" id="uri-references-uri-conformance-uri-references">
<h3>2.3 URI References [uri.conformance.uri-references]<a class="headerlink" href="#uri-references-uri-conformance-uri-references" title="Permalink to this headline">¶</a></h3>
<p>The rule for transforming references is given in IETF RFC 3986,
section 5.2.2.</p>
</div>
<div class="section" id="removing-dot-segments-uri-conformance-removing-dot-segments">
<h3>2.4 Removing Dot Segments [uri.conformance.removing-dot-segments]<a class="headerlink" href="#removing-dot-segments-uri-conformance-removing-dot-segments" title="Permalink to this headline">¶</a></h3>
<p>The rule for removing dot segments is given in IETF RFC 3986, section
5.2.4.</p>
</div>
<div class="section" id="uri-recomposition-uri-conformance-uri-recomposition">
<h3>2.5 URI Recomposition [uri.conformance.uri-recomposition]<a class="headerlink" href="#uri-recomposition-uri-conformance-uri-recomposition" title="Permalink to this headline">¶</a></h3>
<p>The rule for recomposing a URI from its parts is given in IETF RFC
3986, section 5.3.</p>
</div>
</div>
<span id="document-terms_and_definitions"></span><div class="section" id="terms-and-definitions-uri-definitions">
<span id="terms-and-definitions"></span><h2>3 Terms and Definitions [uri.definitions]<a class="headerlink" href="#terms-and-definitions-uri-definitions" title="Permalink to this headline">¶</a></h2>
<div class="section" id="uri-uri-definition-uri">
<h3>3.1 URI [uri.definition.uri]<a class="headerlink" href="#uri-uri-definition-uri" title="Permalink to this headline">¶</a></h3>
<p>A Uniform Resource Identifier is a sequence of characters from a
limited set with a specific syntax used to identify a name or
resource. URIs can be classified as URLs or URNs. The URI syntax is
defined in IETF RFC 3986.</p>
</div>
<div class="section" id="url-uri-definition-url">
<h3>3.2 URL [uri.definition.url]<a class="headerlink" href="#url-uri-definition-url" title="Permalink to this headline">¶</a></h3>
<p>A Uniform Resource Locator (URL) is a type of URI, complementary to a
URN used to locate a resource over a network.</p>
</div>
<div class="section" id="urn-uri-definition-urn">
<h3>3.3 URN [uri.definition.urn]<a class="headerlink" href="#urn-uri-definition-urn" title="Permalink to this headline">¶</a></h3>
<p>A Uniform Resource Name (URN) is a type of URI, complementary to a URL
used to unambiguously identify resources.</p>
</div>
<div class="section" id="iri-uri-definition-iri">
<h3>3.4 IRI [uri.definition.iri]<a class="headerlink" href="#iri-uri-definition-iri" title="Permalink to this headline">¶</a></h3>
<p>An Internationalized Resource Identifier (IRI) is a complement to the
URI that allows characters from the Universal Character Set
(Unicode/ISO 10646). The IRI syntax is defined in IETF RFC 3987.</p>
</div>
<div class="section" id="uri-part-uri-definition-uri-part">
<h3>3.5 URI Part [uri.definition.uri-part]<a class="headerlink" href="#uri-part-uri-definition-uri-part" title="Permalink to this headline">¶</a></h3>
<p>A generic URI is decomposed into four principal parts: the scheme, the
hierarchical part, an optional query and optional fragment. The
hierarchical part can be further decomposed into four parts: the user
info, host, port and path.</p>
</div>
<div class="section" id="scheme-uri-definition-scheme">
<h3>3.6 Scheme [uri.definition.scheme]<a class="headerlink" href="#scheme-uri-definition-scheme" title="Permalink to this headline">¶</a></h3>
<p>A scheme name is the top level of the URI naming structure. It
indicates the specifications, syntax and semantics of the rest of the
URI structure. It is always followed by a colon (&#8221;:&#8221;).</p>
</div>
<div class="section" id="query-uri-definition-query">
<h3>3.7 Query [uri.definition.query]<a class="headerlink" href="#query-uri-definition-query" title="Permalink to this headline">¶</a></h3>
<p>A query is a part, indicated by a question mark (&#8221;?&#8221;) and terminated
by a hash (&#8220;#&#8221;), that contains non-hierarchical information. It is
commonly structured as a sequence of key-value parameter values
separated by equals (&#8220;=&#8221;), which are separated by a semi-colon (&#8221;;&#8221;)
or ampersand (&#8220;&amp;&#8221;).</p>
</div>
<div class="section" id="fragment-uri-definition-fragment">
<h3>3.8 Fragment [uri.definition.fragment]<a class="headerlink" href="#fragment-uri-definition-fragment" title="Permalink to this headline">¶</a></h3>
<p>A fragment is indicated by a hash (&#8220;#&#8221;) and allows indirect
identification of a secondary resource. For example, a fragment may
refer to a section header in an HTML document with an id attribute of
the same name.</p>
</div>
<div class="section" id="hierarchical-part-uri-definition-hierarchical-part">
<h3>3.9 Hierarchical Part [uri.definition.hierarchical-part]<a class="headerlink" href="#hierarchical-part-uri-definition-hierarchical-part" title="Permalink to this headline">¶</a></h3>
<p>The hierarchical part of a URI contains hierarchical information. If
it starts with a double forward slash (&#8220;//&#8221;), it is followed by an
authority and a path. The authority can be further broken down into a
user-information part, a hostname and a port. The authority is
followed by an optional path. If the hierarchical part does not begin
with a double forward slash (&#8220;//&#8221;), then it must contain a path.</p>
</div>
<div class="section" id="authority-uri-definition-authority">
<h3>3.10 Authority [uri.definition.authority]<a class="headerlink" href="#authority-uri-definition-authority" title="Permalink to this headline">¶</a></h3>
<p>The hierarchical part contains an authority. The authority contains an
optional user info followed by at (&#8220;&#64;&#8221;), a host and an optional port,
preceded by a colon (&#8221;:&#8221;).</p>
</div>
<div class="section" id="user-info-uri-definition-user-info">
<h3>3.11 User Info [uri.definition.user-info]<a class="headerlink" href="#user-info-uri-definition-user-info" title="Permalink to this headline">¶</a></h3>
<p>The user info is an optional part of the URI authority, terminated by
at (&#8220;&#64;&#8221;) and is followed by a host. It is used in the telnet scheme:</p>
<div class="highlight-python"><pre>telnet://&lt;user&gt;:&lt;password&gt;@&lt;host&gt;:&lt;port&gt;/</pre>
</div>
</div>
<div class="section" id="host-uri-definition-host">
<h3>3.12 Host [uri.definition.host]<a class="headerlink" href="#host-uri-definition-host" title="Permalink to this headline">¶</a></h3>
<p>The hostname contains a domain name or IP address.</p>
</div>
<div class="section" id="domain-name-uri-definition-domain-name">
<h3>3.13 Domain Name [uri.definition.domain-name]<a class="headerlink" href="#domain-name-uri-definition-domain-name" title="Permalink to this headline">¶</a></h3>
<p>A domain name is human-readable string used to identify a host. Domain
names are registered in the Domain Name System (DNS).</p>
</div>
<div class="section" id="ip-address-uri-definition-ip-address">
<h3>3.14 IP Address [uri.definition.ip-address]<a class="headerlink" href="#ip-address-uri-definition-ip-address" title="Permalink to this headline">¶</a></h3>
<p>The IP address can either be an IPv4 (e.g. <tt class="docutils literal"><span class="pre">127.0.0.1</span></tt>) or an IPv6
address (e.g. <tt class="docutils literal"><span class="pre">::1</span></tt>. In a URI, an IPv6 address is enclosed in square
braces (&#8220;[]&#8221;).</p>
</div>
<div class="section" id="port-uri-definition-port">
<h3>3.15 Port [uri.definition.port]<a class="headerlink" href="#port-uri-definition-port" title="Permalink to this headline">¶</a></h3>
<p>The optional port is always preceded by a colon (&#8221;:&#8221;). If the port is
not present, even if a colon is present, then the port is considered
to have the value of the default port of the scheme.</p>
</div>
<div class="section" id="path-uri-definition-path">
<h3>3.16 Path [uri.definition.path]<a class="headerlink" href="#path-uri-definition-path" title="Permalink to this headline">¶</a></h3>
<p>The path is a part of the hierarchical data and is a sequence of
segments, each separated by a forward slash (&#8220;/&#8221;). It is terminated by
a question mark (&#8221;?&#8221;), followed by a query, a hash (&#8220;#&#8221;) followed by a
fragment or by the end of the URI.</p>
</div>
<div class="section" id="dot-segments-uri-definition-dot-segments">
<h3>3.17 Dot Segments [uri.definition.dot-segments]<a class="headerlink" href="#dot-segments-uri-definition-dot-segments" title="Permalink to this headline">¶</a></h3>
<p>Dot segments are elements in a path containing either a dot (&#8221;.&#8221;) or a
double dot (&#8221;..&#8221;), separated by a forward slash (&#8220;/&#8221;). Dot segments
can be removed from a path as part of its normalization without
changing the URI semantics.</p>
</div>
<div class="section" id="absolute-uri-uri-definition-absolute-uri">
<h3>3.18 Absolute URI [uri.definition.absolute-uri]<a class="headerlink" href="#absolute-uri-uri-definition-absolute-uri" title="Permalink to this headline">¶</a></h3>
<p>An absolute URI always specifies the scheme. URIs that don&#8217;t provide
the scheme are called relative references.</p>
</div>
<div class="section" id="opaque-uri-uri-definition-opaque-uri">
<h3>3.19 Opaque URI [uri.definition.opaque-uri]<a class="headerlink" href="#opaque-uri-uri-definition-opaque-uri" title="Permalink to this headline">¶</a></h3>
<p>An opaque URI is an absolute URI that does not provide a double slash
(&#8220;//&#8221;) after the scheme-delimiting colon (&#8221;:&#8221;). Opaque URIs have no
authority and the part immediately following the colon (&#8221;:&#8221;) is the
path. Some examples of opaque URIs are:</p>
<div class="highlight-python"><pre>mailto:john.doe@example.com
news:comp.lang.c++</pre>
</div>
<p>URIs that provide a double slash (&#8220;//&#8221;) following the
scheme-delimiting colon (&#8221;:&#8221;) are known as hierarchical URIs. Some
examples are:</p>
<div class="highlight-python"><pre>http://www.example.com/
ftp://john.doe@ftp.example.com/</pre>
</div>
</div>
<div class="section" id="normalization-uri-definition-normalization">
<h3>3.20 Normalization [uri.definition.normalization]<a class="headerlink" href="#normalization-uri-definition-normalization" title="Permalink to this headline">¶</a></h3>
<p>URI normalization is the process by which a URI is transformed in
order to determine of two URIs are equivalent. There are different
levels to comparison, which trade-off the number of false negatives
and complexity. The normalization and comparison procedures are
defined in IETF RFC 3986, section 6.</p>
</div>
<div class="section" id="comparison-ladder-uri-definition-comparison-ladder">
<h3>3.21 Comparison Ladder [uri.definition.comparison-ladder]<a class="headerlink" href="#comparison-ladder-uri-definition-comparison-ladder" title="Permalink to this headline">¶</a></h3>
<p>The comparison ladder describes how URIs can be compared using
normalization in different ways, trading off the complexity of the
method and the number of false negatives. The comparison ladder is
defined in IETF RFC 3986, section 6.2 and IETF RFC 3987, section 5.3.</p>
</div>
<div class="section" id="relative-reference-uri-definition-relative-reference">
<h3>3.22 Relative Reference [uri.definition.relative-reference]<a class="headerlink" href="#relative-reference-uri-definition-relative-reference" title="Permalink to this headline">¶</a></h3>
<p>Relative references are URIs that do not provide a scheme. Relative
references are only usable when a base URI is known, against which the
relative reference can be resolved. The relative reference is defined
in IETF RFC 3986, section 4.2 and IETF RFC 3987, section 6.5.</p>
</div>
<div class="section" id="reference-resolution-uri-definition-reference-resolution">
<h3>3.23 Reference Resolution [uri.definition.reference-resolution]<a class="headerlink" href="#reference-resolution-uri-definition-reference-resolution" title="Permalink to this headline">¶</a></h3>
<p>Relative references can be resolved against a base URI, producing an
absolute URI. Only the scheme is required to be present in the base
URI. Reference resolution is defined in IETF RFC 3986, section 5.</p>
<p>Pre-parsing and normalization of the URI is performed before
transforming the reference.</p>
<p>The transform reference for resolving URIs is given in IETF RFC 3986,
section 5.2.2.</p>
</div>
<div class="section" id="percent-encoding-uri-definition-percent-encoding">
<h3>3.24 Percent Encoding [uri.definition.percent-encoding]<a class="headerlink" href="#percent-encoding-uri-definition-percent-encoding" title="Permalink to this headline">¶</a></h3>
<p>Percent encoding is the mechanism used to encode reserved characters
in a URI. See IETF RFC 3986, section 2.1.</p>
</div>
<div class="section" id="case-normalization-uri-definition-case-normalization">
<h3>3.25 Case Normalization [uri.definition.case-normalization]<a class="headerlink" href="#case-normalization-uri-definition-case-normalization" title="Permalink to this headline">¶</a></h3>
<p>All characters in a URI scheme and host must be lower-case. All
hexidecimal digits within a percent-encoded triplet must be
upper-case. See IETF RFC 3986, section 6.2.2.1 and IETF RFC 3987,
section 5.3.2.1.</p>
</div>
<div class="section" id="percent-encoding-normalization-uri-definition-percent-encoding-normalization">
<h3>3.26 Percent Encoding Normalization [uri.definition.percent-encoding-normalization]<a class="headerlink" href="#percent-encoding-normalization-uri-definition-percent-encoding-normalization" title="Permalink to this headline">¶</a></h3>
<p>URIs should be normalized by decoding any percent-encoded octet that
corresponds to a an unreserved character. See IETF RFC 3986, section
6.2.2.2 and IETF RFC 3987, section 5.3.2.3.</p>
</div>
<div class="section" id="path-segment-normalization-uri-definition-path-segment-normalization">
<h3>3.27 Path Segment Normalization [uri.definition.path-segment-normalization]<a class="headerlink" href="#path-segment-normalization-uri-definition-path-segment-normalization" title="Permalink to this headline">¶</a></h3>
<p>Path segments [uri.definition.dot-segments] should be removed from
URIs that are not relative references. See IETF RFC 3986, section
6.2.2.3 and IETF RFC 3987, section 5.3.2.4.</p>
</div>
<div class="section" id="character-normalization-uri-definition-character-normalization">
<h3>3.28 Character Normalization [uri.definition.character-normalization]<a class="headerlink" href="#character-normalization-uri-definition-character-normalization" title="Permalink to this headline">¶</a></h3>
<p>In Unicode, different sequences of characters could be defined as
equivalent depending on how they are encoded. See IETF RFC 3987,
section 5.3.2.2.</p>
</div>
<div class="section" id="ipv6-zone-ids-uri-definition-ipv6-zone-ids">
<h3>3.29 IPv6 Zone IDs [uri.definition.ipv6-zone-ids]<a class="headerlink" href="#ipv6-zone-ids-uri-definition-ipv6-zone-ids" title="Permalink to this headline">¶</a></h3>
<p>A zone index is used to identify to which scope a non-global address
belongs in an IPv6 address. It is specified in IETF RFC 6874.</p>
</div>
</div>
<span id="document-requirements"></span><div class="section" id="requirements-uri-requirements">
<span id="requirements"></span><h2>4 Requirements [uri.requirements]<a class="headerlink" href="#requirements-uri-requirements" title="Permalink to this headline">¶</a></h2>
<p>Template parameters named InputIterator shall meet the C++ Standard&#8217;s
library input iterator requirements ([input.iterators]) and shall have
a value type that is one of the encoded character types.</p>
<p>The <tt class="docutils literal"><span class="pre">uri</span></tt> class must be able to parse according to the rules
described in IETF RFC 3986, Section 3.</p>
<p>The <tt class="docutils literal"><span class="pre">uri</span></tt> class must be able to correctly parse IPv6 addresses,
described in IETF RFC 2732.</p>
<p>The <tt class="docutils literal"><span class="pre">uri</span></tt> class must be able to parse internationalized <tt class="docutils literal"><span class="pre">uri</span></tt>
class according to IETF RFC 3987, section 2.</p>
<p>The <tt class="docutils literal"><span class="pre">uri</span></tt> class must be able to parse zone IDs in IPv6 addresses
according to IETF RFC 6874, section 2.</p>
</div>
<span id="document-header_synopsis"></span><div class="section" id="header-experimental-uri-synopsis-uri-header-synopsis">
<span id="header-synopsis"></span><h2>5 Header <tt class="docutils literal"><span class="pre">&lt;experimental/uri&gt;</span></tt> Synopsis [uri.header-synopsis]<a class="headerlink" href="#header-experimental-uri-synopsis-uri-header-synopsis" title="Permalink to this headline">¶</a></h2>
<div class="highlight-c++"><div class="highlight"><pre><span class="cp">#include &lt;string&gt;        </span><span class="c1">// std::basic_string</span>
<span class="cp">#include &lt;system_error&gt;  </span><span class="c1">// std::error_code</span>
<span class="cp">#include &lt;iosfwd&gt;        </span><span class="c1">// std::basic_istream, std::basic_ostream</span>
<span class="cp">#include &lt;iterator&gt;      </span><span class="c1">// std::iterator_traits</span>
<span class="cp">#include &lt;memory&gt;        </span><span class="c1">// std::allocator</span>
<span class="cp">#include &lt;optional&gt;      </span><span class="c1">// std::optional</span>
<span class="cp">#include &lt;functional&gt;    </span><span class="c1">// std::hash</span>

<span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="c1">// class declarations</span>
<span class="k">class</span> <span class="nc">uri</span><span class="p">;</span>
<span class="k">class</span> <span class="nc">uri_builder</span><span class="p">;</span>
<span class="k">class</span> <span class="nc">uri_syntax_error</span><span class="p">;</span>
<span class="k">class</span> <span class="nc">base_uri_error</span><span class="p">;</span>
<span class="k">class</span> <span class="nc">uri_builder_error</span><span class="p">;</span>
<span class="k">class</span> <span class="nc">percent_decoding_error</span><span class="p">;</span>

<span class="k">enum</span> <span class="k">class</span> <span class="nc">uri_error</span> <span class="p">{</span>
 <span class="c1">// uri syntax errors</span>
 <span class="n">invalid_syntax</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span>

 <span class="c1">// uri reference and resolution errors</span>
 <span class="n">base_uri_is_empty</span><span class="p">,</span>
 <span class="n">base_uri_is_not_absolute</span><span class="p">,</span>
 <span class="n">base_uri_is_opaque</span><span class="p">,</span>
 <span class="n">base_uri_does_not_match</span><span class="p">,</span>

 <span class="c1">// builder errors</span>
 <span class="n">invalid_uri</span><span class="p">,</span>
 <span class="n">invalid_scheme</span><span class="p">,</span>
 <span class="n">invalid_user_info</span><span class="p">,</span>
 <span class="n">invalid_host</span><span class="p">,</span>
 <span class="n">invalid_port</span><span class="p">,</span>
 <span class="n">invalid_path</span><span class="p">,</span>
 <span class="n">invalid_query</span><span class="p">,</span>
 <span class="n">invalid_fragment</span><span class="p">,</span>

 <span class="c1">// decoding errors</span>
 <span class="n">not_enough_input</span><span class="p">,</span>
 <span class="n">non_hex_input</span><span class="p">,</span>
 <span class="n">conversion_failed</span><span class="p">,</span>
<span class="p">};</span>

<span class="k">enum</span> <span class="k">class</span> <span class="nc">uri_normalization_level</span> <span class="p">{</span>
 <span class="n">string_comparison</span><span class="p">,</span>
 <span class="n">syntax_based</span><span class="p">,</span>
<span class="p">};</span>

<span class="c1">// factory functions</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">make_uri</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">source</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">make_uri</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">first</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">last</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">make_uri</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">source</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">make_uri</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">first</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">last</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">,</span>
             <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">);</span>

<span class="c1">// equality and comparison operators</span>
<span class="kt">bool</span> <span class="k">operator</span><span class="o">==</span> <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="kt">bool</span> <span class="k">operator</span><span class="o">!=</span> <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="kt">bool</span> <span class="k">operator</span><span class="o">&lt;</span>  <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="kt">bool</span> <span class="k">operator</span><span class="o">&gt;</span>  <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="kt">bool</span> <span class="k">operator</span><span class="o">&lt;=</span> <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="kt">bool</span> <span class="k">operator</span><span class="o">&gt;=</span> <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>

<span class="c1">// stream operators</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CharT</span><span class="p">,</span> <span class="k">class</span> <span class="nc">CharTraits</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">char_traits</span><span class="o">&lt;</span><span class="n">CharT</span><span class="o">&gt;&gt;</span>
<span class="n">std</span><span class="o">::</span><span class="n">basic_ostream</span><span class="o">&lt;</span><span class="n">CharT</span><span class="p">,</span> <span class="n">CharTraits</span><span class="o">&gt;&amp;</span>
<span class="k">operator</span><span class="o">&lt;&lt;</span> <span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">basic_ostream</span><span class="o">&lt;</span><span class="n">CharT</span><span class="p">,</span> <span class="n">CharTraits</span><span class="o">&gt;&amp;</span> <span class="n">os</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">u</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CharT</span><span class="p">,</span> <span class="k">class</span> <span class="nc">CharTraits</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">char_traits</span><span class="o">&lt;</span><span class="n">CharT</span><span class="o">&gt;&gt;</span>
<span class="n">std</span><span class="o">::</span><span class="n">basic_istream</span><span class="o">&lt;</span><span class="n">CharT</span><span class="p">,</span> <span class="n">CharTraits</span><span class="o">&gt;&amp;</span>
<span class="k">operator</span><span class="o">&gt;&gt;</span> <span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">basic_istream</span><span class="o">&lt;</span><span class="n">CharT</span><span class="p">,</span> <span class="n">CharTraits</span><span class="o">&gt;&amp;</span> <span class="n">is</span><span class="p">,</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">u</span><span class="p">);</span>

<span class="c1">// swap functions</span>
<span class="kt">void</span> <span class="n">swap</span><span class="p">(</span><span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="p">}</span> <span class="c1">// namespace experimental</span>

<span class="k">template</span> <span class="o">&lt;&gt;</span>
<span class="k">struct</span> <span class="n">hash</span><span class="o">&lt;</span><span class="n">experimental</span><span class="o">::</span><span class="n">uri</span><span class="o">&gt;</span> <span class="p">{</span>
 <span class="n">size_t</span> <span class="k">operator</span> <span class="p">()</span> <span class="p">(</span><span class="k">const</span> <span class="n">experimental</span><span class="o">::</span><span class="n">uri</span> <span class="o">&amp;</span><span class="n">u</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
<span class="p">};</span>

<span class="k">template</span> <span class="o">&lt;&gt;</span>
<span class="k">struct</span> <span class="n">is_error_code_enum</span><span class="o">&lt;</span><span class="n">experimental</span><span class="o">::</span><span class="n">uri_error</span><span class="o">&gt;</span> <span class="o">:</span> <span class="k">public</span> <span class="n">true_type</span> <span class="p">{</span> <span class="p">};</span>
<span class="p">}</span> <span class="c1">// namespace std</span>
</pre></div>
</div>
<div class="section" id="declarations-uri-header-synopsis-declarations">
<h3>5.1 Declarations [uri.header-synopsis.declarations]<a class="headerlink" href="#declarations-uri-header-synopsis-declarations" title="Permalink to this headline">¶</a></h3>
<p>The <tt class="docutils literal"><span class="pre">&lt;experimental/uri&gt;</span></tt> header contains a declaration for a <tt class="docutils literal"><span class="pre">uri</span></tt>
class, a <tt class="docutils literal"><span class="pre">uri_builder</span></tt> class and execption classes,
<tt class="docutils literal"><span class="pre">uri_syntax_error</span></tt>, <tt class="docutils literal"><span class="pre">uri_builder_error</span></tt> and
<tt class="docutils literal"><span class="pre">percent_decoding_error</span></tt> in the <tt class="docutils literal"><span class="pre">std::experimental</span></tt> namespace.</p>
</div>
<div class="section" id="factory-functions-uri-header-synopsis-factory-functions">
<h3>5.2 Factory functions [uri.header-synopsis.factory-functions]<a class="headerlink" href="#factory-functions-uri-header-synopsis-factory-functions" title="Permalink to this headline">¶</a></h3>
<div class="highlight-c++"><div class="highlight"><pre><span class="c1">// factory functions</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">make_uri</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">source</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs an object of class <tt class="docutils literal"><span class="pre">uri</span></tt>. The source is
copied into the <tt class="docutils literal"><span class="pre">uri</span></tt> object and parsed. The encoding
is assumed to depend on the underlying character type and
implementation. On error, the <tt class="docutils literal"><span class="pre">error_code</span></tt> is set and
<tt class="docutils literal"><span class="pre">make_uri</span></tt> returns an empty <tt class="docutils literal"><span class="pre">uri</span></tt> object.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">make_uri</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">first</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">last</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs an object of class <tt class="docutils literal"><span class="pre">uri</span></tt>. The source is
copied into the <tt class="docutils literal"><span class="pre">uri</span></tt> object and parsed. The encoding
is assumed to depend on the underlying character type and
implementation. On error, the <tt class="docutils literal"><span class="pre">error_code</span></tt> is set and
<tt class="docutils literal"><span class="pre">make_uri</span></tt> returns an empty <tt class="docutils literal"><span class="pre">uri</span></tt> object.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">make_uri</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">source</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs an object of class <tt class="docutils literal"><span class="pre">uri</span></tt>. The source is
copied into the <tt class="docutils literal"><span class="pre">uri</span></tt> object and parsed. The encoding
is assumed to depend on the underlying character type and
implementation. On error, the <tt class="docutils literal"><span class="pre">error_code</span></tt> is set and
<tt class="docutils literal"><span class="pre">make_uri</span></tt> returns an empty <tt class="docutils literal"><span class="pre">uri</span></tt> object. All memory
allocation shall be performed by <tt class="docutils literal"><span class="pre">alloc</span></tt>.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">make_uri</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">first</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">last</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">,</span>
             <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs an object of class <tt class="docutils literal"><span class="pre">uri</span></tt>. The source is
copied into the <tt class="docutils literal"><span class="pre">uri</span></tt> object and parsed. The encoding
is assumed to depend on the underlying character type and
implementation. On error, the <tt class="docutils literal"><span class="pre">error_code</span></tt> is set and
<tt class="docutils literal"><span class="pre">make_uri</span></tt> returns an empty <tt class="docutils literal"><span class="pre">uri</span></tt> object. All memory
allocation shall be performed by <tt class="docutils literal"><span class="pre">alloc</span></tt>.</div>
</div>
</div>
<div class="section" id="equality-and-comparison-operators-uri-header-synopsis-equality-comparison">
<h3>5.3 Equality and Comparison Operators [uri.header-synopsis.equality-comparison]<a class="headerlink" href="#equality-and-comparison-operators-uri-header-synopsis-equality-comparison" title="Permalink to this headline">¶</a></h3>
<div class="highlight-c++"><div class="highlight"><pre><span class="kt">bool</span> <span class="k">operator</span><span class="o">==</span> <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="kt">bool</span> <span class="k">operator</span><span class="o">!=</span> <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Common overloads of the equality and inequality operators
use <em>string_comparison</em>.</div>
</div>
<blockquote>
<div><tt class="docutils literal"><span class="pre">lhs.compare(rhs,</span> <span class="pre">uri_normalization_level::syntax_based)</span> <span class="pre">==</span> <span class="pre">0</span></tt>
and <tt class="docutils literal"><span class="pre">!(lhs</span> <span class="pre">==</span> <span class="pre">rhs)</span></tt>.</div></blockquote>
<div class="highlight-c++"><div class="highlight"><pre><span class="kt">bool</span> <span class="k">operator</span><span class="o">&lt;</span>  <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="kt">bool</span> <span class="k">operator</span><span class="o">&gt;</span>  <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="kt">bool</span> <span class="k">operator</span><span class="o">&lt;=</span> <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="kt">bool</span> <span class="k">operator</span><span class="o">&gt;=</span> <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Common overloads of the comparison operators use
<em>string_comparison</em>.</div>
</div>
<blockquote>
<div><tt class="docutils literal"><span class="pre">lhs.compare(rhs,</span> <span class="pre">uri_normalization_level::syntax_based)</span> <span class="pre">&lt;</span> <span class="pre">0</span></tt>,
<tt class="docutils literal"><span class="pre">(rhs</span> <span class="pre">&lt;</span> <span class="pre">lhs)</span></tt>, <tt class="docutils literal"><span class="pre">!(rhs</span> <span class="pre">&lt;</span> <span class="pre">lhs)</span></tt> and <tt class="docutils literal"><span class="pre">!(lhs</span> <span class="pre">&lt;</span> <span class="pre">rhs)</span></tt>.</div></blockquote>
</div>
<div class="section" id="stream-operators-uri-header-synopsis-stream-operators">
<h3>5.4 Stream Operators [uri.header-synopsis.stream-operators]<a class="headerlink" href="#stream-operators-uri-header-synopsis-stream-operators" title="Permalink to this headline">¶</a></h3>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CharT</span><span class="p">,</span> <span class="k">class</span> <span class="nc">CharTraits</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">char_traits</span><span class="o">&lt;</span><span class="n">CharT</span><span class="o">&gt;&gt;</span>
<span class="n">std</span><span class="o">::</span><span class="n">basic_ostream</span><span class="o">&lt;</span><span class="n">CharT</span><span class="p">,</span> <span class="n">CharTraits</span><span class="o">&gt;&amp;</span>
<span class="k">operator</span><span class="o">&lt;&lt;</span> <span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">basic_ostream</span><span class="o">&lt;</span><span class="n">CharT</span><span class="p">,</span> <span class="n">CharTraits</span><span class="o">&gt;&amp;</span> <span class="n">os</span><span class="p">,</span> <span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">u</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: <tt class="docutils literal"><span class="pre">os</span> <span class="pre">&lt;&lt;</span> <span class="pre">u.string&lt;CharT,</span> <span class="pre">CharTraits&gt;();</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CharT</span><span class="p">,</span> <span class="k">class</span> <span class="nc">CharTraits</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">char_traits</span><span class="o">&lt;</span><span class="n">CharT</span><span class="o">&gt;&gt;</span>
<span class="n">std</span><span class="o">::</span><span class="n">basic_istream</span><span class="o">&lt;</span><span class="n">CharT</span><span class="p">,</span> <span class="n">CharTraits</span><span class="o">&gt;&amp;</span>
<span class="k">operator</span><span class="o">&gt;&gt;</span> <span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">basic_istream</span><span class="o">&lt;</span><span class="n">CharT</span><span class="p">,</span> <span class="n">CharTraits</span><span class="o">&gt;&amp;</span> <span class="n">is</span><span class="p">,</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">u</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: <tt class="docutils literal"><span class="pre">string&lt;CharT,</span> <span class="pre">CharTraits&gt;</span> <span class="pre">tmp;</span> <span class="pre">is</span> <span class="pre">&gt;&gt;</span> <span class="pre">tmp;</span> <span class="pre">std::error_code</span> <span class="pre">ec;</span> <span class="pre">u</span> <span class="pre">=</span> <span class="pre">make_uri(tmp,</span> <span class="pre">ec);</span> <span class="pre">if</span> <span class="pre">(ec)</span> <span class="pre">is.setstate(ios::fail);</span></tt></div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
</div>
<div class="section" id="swap-uri-header-synopsis-swap">
<h3>5.5 Swap [uri.header-synopsis.swap]<a class="headerlink" href="#swap-uri-header-synopsis-swap" title="Permalink to this headline">¶</a></h3>
<div class="highlight-c++"><div class="highlight"><pre><span class="kt">void</span> <span class="n">swap</span><span class="p">(</span><span class="n">uri</span><span class="o">&amp;</span> <span class="n">lhs</span><span class="p">,</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">rhs</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: <tt class="docutils literal"><span class="pre">lhs.swap(rhs);</span></tt></div>
</div>
</div>
<div class="section" id="uri-hash-uri-header-synopsis-hash">
<h3>5.6 URI Hash [uri.header-synopsis.hash]<a class="headerlink" href="#uri-hash-uri-header-synopsis-hash" title="Permalink to this headline">¶</a></h3>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;&gt;</span>
<span class="k">struct</span> <span class="n">hash</span><span class="o">&lt;</span><span class="n">experimental</span><span class="o">::</span><span class="n">uri</span><span class="o">&gt;</span> <span class="p">{</span>
 <span class="n">size_t</span> <span class="k">operator</span> <span class="p">()</span> <span class="p">(</span><span class="k">const</span> <span class="n">experimental</span><span class="o">::</span><span class="n">uri</span> <span class="o">&amp;</span><span class="n">u</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
<span class="p">};</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A hash value of uri <tt class="docutils literal"><span class="pre">u</span></tt>.</div>
</div>
</div>
<div class="section" id="error-code-enumeration-uri-error-code-enumeration">
<h3>5.7 Error code enumeration [uri.error-code-enumeration]<a class="headerlink" href="#error-code-enumeration-uri-error-code-enumeration" title="Permalink to this headline">¶</a></h3>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;&gt;</span>
<span class="k">struct</span> <span class="n">is_error_code_enum</span><span class="o">&lt;</span><span class="n">experimental</span><span class="o">::</span><span class="n">uri_error</span><span class="o">&gt;</span> <span class="o">:</span> <span class="k">public</span> <span class="n">true_type</span> <span class="p">{</span> <span class="p">};</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Allows <tt class="docutils literal"><span class="pre">uri_error</span></tt> values to be used in
<tt class="docutils literal"><span class="pre">std::error_code</span></tt>.</div>
</div>
</div>
</div>
<span id="document-error_reporting"></span><div class="section" id="error-reporting-uri-error-reporting">
<span id="error-reporting"></span><h2>6 Error Reporting [uri.error-reporting]<a class="headerlink" href="#error-reporting-uri-error-reporting" title="Permalink to this headline">¶</a></h2>
<p>Some URI functions provide two overloads, one that throws an exception
to report errors, and a second that sets an <tt class="docutils literal"><span class="pre">std::error_code</span></tt>.</p>
<p>Member functions of <tt class="docutils literal"><span class="pre">uri</span></tt> not having an error of type
<tt class="docutils literal"><span class="pre">std::error_code&amp;</span></tt> report errors as follow, unless otherwise
specified:</p>
<ul class="simple">
<li>A <tt class="docutils literal"><span class="pre">uri_syntax_error</span></tt> or <tt class="docutils literal"><span class="pre">base_uri_error</span></tt> is thrown, depending
on the context.</li>
<li>Failure to allocate storage is reported by throwing an exception as
describe in the C++ standard, 17.6.4.10 [res.on.exception.handling].</li>
</ul>
<p>Functions that have an error of type <tt class="docutils literal"><span class="pre">std::error_code&amp;</span></tt> report
errors as follows:</p>
<ul class="simple">
<li>If a parsing error indicates an invalid URI, or a URI relative
reference is passed as a base URI, the <tt class="docutils literal"><span class="pre">std::error_code&amp;</span></tt> argument
is set as appropriate for the specific error. Otherwise, <tt class="docutils literal"><span class="pre">clear</span></tt>
is called on the <tt class="docutils literal"><span class="pre">error_code&amp;</span></tt> argument.</li>
</ul>
</div>
<span id="document-class_uri"></span><div class="section" id="class-uri-class-uri">
<span id="class-uri"></span><h2>7 Class <tt class="docutils literal"><span class="pre">uri</span></tt> [class.uri]<a class="headerlink" href="#class-uri-class-uri" title="Permalink to this headline">¶</a></h2>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="k">class</span> <span class="nc">uri</span> <span class="p">{</span>

<span class="k">public</span><span class="o">:</span>

    <span class="c1">// typedefs</span>
    <span class="k">typedef</span> <span class="o">*</span><span class="n">unspecified</span><span class="o">*</span> <span class="n">string_type</span><span class="p">;</span>
    <span class="k">typedef</span> <span class="o">*</span><span class="n">unspecified</span><span class="o">*</span> <span class="n">iterator</span><span class="p">;</span>
    <span class="k">typedef</span> <span class="o">*</span><span class="n">unspecified</span><span class="o">*</span> <span class="n">const_iterator</span><span class="p">;</span>
    <span class="k">typedef</span> <span class="n">std</span><span class="o">::</span><span class="n">iterator_traits</span><span class="o">&lt;</span><span class="n">iterator</span><span class="o">&gt;::</span><span class="n">value_type</span> <span class="n">value_type</span><span class="p">;</span>
    <span class="k">typedef</span> <span class="n">basic_string_view</span><span class="o">&lt;</span><span class="n">value_type</span><span class="o">&gt;</span> <span class="n">string_view</span><span class="p">;</span>

    <span class="c1">// constructors and destructor</span>
    <span class="n">uri</span><span class="p">();</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Allocator</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">allocator</span><span class="o">&lt;</span><span class="n">value_type</span><span class="o">&gt;&gt;</span>
    <span class="k">explicit</span> <span class="n">uri</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">source</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span> <span class="o">=</span> <span class="n">Allocator</span><span class="p">());</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Allocator</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">allocator</span><span class="o">&lt;</span><span class="n">value_type</span><span class="o">&gt;&gt;</span>
    <span class="n">uri</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span> <span class="o">=</span> <span class="n">Allocator</span><span class="p">());</span>
    <span class="n">uri</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">);</span>
    <span class="n">uri</span><span class="p">(</span><span class="n">uri</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
    <span class="o">~</span><span class="n">uri</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>

    <span class="c1">// assignment</span>
    <span class="n">uri</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span> <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">);</span>
    <span class="n">uri</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span> <span class="p">(</span><span class="n">uri</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>

    <span class="c1">// modifiers</span>
    <span class="kt">void</span> <span class="n">swap</span><span class="p">(</span><span class="n">uri</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>

    <span class="c1">// iterators</span>
    <span class="n">const_iterator</span> <span class="n">begin</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">const_iterator</span> <span class="n">end</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">const_iterator</span> <span class="n">cbegin</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">const_iterator</span> <span class="n">cend</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>

    <span class="c1">// accessors</span>
    <span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">scheme</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">user_info</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">host</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">port</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">IntT</span><span class="o">&gt;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">IntT</span><span class="o">&gt;</span> <span class="n">port</span><span class="p">(</span><span class="k">typename</span> <span class="n">std</span><span class="o">::</span><span class="n">is_integral</span><span class="o">&lt;</span><span class="n">IntT</span><span class="o">&gt;::</span><span class="n">type</span><span class="o">*</span> <span class="o">=</span> <span class="mi">0</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">path</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">authority</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">query</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">fragment</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>

    <span class="c1">// string accessors</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CharT</span><span class="p">,</span>
              <span class="k">class</span> <span class="nc">CharTraits</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">char_traits</span><span class="o">&lt;</span><span class="n">CharT</span><span class="o">&gt;</span><span class="p">,</span>
              <span class="k">class</span> <span class="nc">Allocator</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">allocator</span><span class="o">&lt;</span><span class="n">CharT</span><span class="o">&gt;&gt;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">basic_string</span><span class="o">&lt;</span><span class="n">CharT</span><span class="p">,</span> <span class="n">CharTraits</span><span class="p">,</span> <span class="n">Allocator</span><span class="o">&gt;</span>
    <span class="n">to_string</span><span class="p">(</span><span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span> <span class="o">=</span> <span class="n">Allocator</span><span class="p">())</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">string</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">wstring</span> <span class="n">wstring</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">u8string</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">u16string</span> <span class="n">u16string</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">std</span><span class="o">::</span><span class="n">u32string</span> <span class="n">u32string</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>

    <span class="c1">// query</span>
    <span class="kt">bool</span> <span class="n">empty</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
    <span class="kt">bool</span> <span class="n">is_absolute</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
    <span class="kt">bool</span> <span class="n">is_opaque</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>

    <span class="c1">// transformers</span>
    <span class="n">uri</span> <span class="n">normalize</span><span class="p">(</span><span class="n">uri_normalization_level</span> <span class="n">level</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
    <span class="n">uri</span> <span class="n">normalize</span><span class="p">(</span><span class="n">uri_normalization_level</span> <span class="n">level</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">uri</span> <span class="n">normalize</span><span class="p">(</span><span class="n">uri_normalization_level</span> <span class="n">level</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
    <span class="n">uri</span> <span class="n">normalize</span><span class="p">(</span><span class="n">uri_normalization_level</span> <span class="n">level</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">,</span>
                  <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>

    <span class="n">uri</span> <span class="n">make_relative</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
    <span class="n">uri</span> <span class="n">make_relative</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">uri</span> <span class="n">make_relative</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
    <span class="n">uri</span> <span class="n">make_relative</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">,</span>
                      <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>

    <span class="n">uri</span> <span class="n">resolve</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
    <span class="n">uri</span> <span class="n">resolve</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
    <span class="n">uri</span> <span class="n">resolve</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
    <span class="n">uri</span> <span class="n">resolve</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">,</span>
                <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>

    <span class="c1">// comparison</span>
    <span class="kt">int</span> <span class="n">compare</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">,</span> <span class="n">uri_normalization_level</span> <span class="n">level</span><span class="p">)</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>

    <span class="c1">// percent encoding and decoding</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
    <span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_user_info</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                           <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
    <span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_host</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                      <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
    <span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_port</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                      <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
    <span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_path</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                      <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
    <span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_query</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                       <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
    <span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_fragment</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                          <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
    <span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">decode</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                 <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>

<span class="p">};</span>
<span class="p">}</span> <span class="c1">// namespace experimental</span>
<span class="p">}</span> <span class="c1">// namespace std</span>
</pre></div>
</div>
<div class="section" id="uri-requirements-class-uri-reqs">
<h3>7.1 <tt class="docutils literal"><span class="pre">uri</span></tt> Requirements [class.uri.reqs]<a class="headerlink" href="#uri-requirements-class-uri-reqs" title="Permalink to this headline">¶</a></h3>
<p><tt class="docutils literal"><span class="pre">string_type</span></tt> is <em>unspecified</em> and is not required to be a
contiguous memory block. As a consequence, <tt class="docutils literal"><span class="pre">iterator</span></tt> and
<tt class="docutils literal"><span class="pre">const_iterator</span></tt> are also <em>unspecified</em>. Should an
implementor decide to use a contiguous string (e.g. <tt class="docutils literal"><span class="pre">std::string</span></tt>),
<tt class="docutils literal"><span class="pre">iterator</span></tt> and <tt class="docutils literal"><span class="pre">const_iterator</span></tt> can be
<tt class="docutils literal"><span class="pre">string_type::const_iterator</span></tt>. Each URI part is required to be a
contiguous memory block.</p>
<p>Function template parameters named <tt class="docutils literal"><span class="pre">Source</span></tt> shall be one of:</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">basic_string&lt;CharT,</span> <span class="pre">CharTraits,</span> <span class="pre">Allocator&gt;</span></tt>. The type charT shall
be an encoded character type.  A function argument <tt class="docutils literal"><span class="pre">const</span> <span class="pre">Source&amp;</span>
<span class="pre">source</span></tt> shall have an effective range [<tt class="docutils literal"><span class="pre">cbegin(source)</span></tt>,
<tt class="docutils literal"><span class="pre">cend(source)</span></tt>).</li>
<li><tt class="docutils literal"><span class="pre">basic_string_view&lt;CharT,</span> <span class="pre">CharTraits&gt;</span></tt>. The type charT shall be an
encoded character type.  A function argument <tt class="docutils literal"><span class="pre">const</span> <span class="pre">Source&amp;</span>
<span class="pre">source</span></tt> shall have an effective range [<tt class="docutils literal"><span class="pre">cbegin(source)</span></tt>,
<tt class="docutils literal"><span class="pre">cend(source)</span></tt>).</li>
<li>A type meeting the input iterator requirements that iterates over a
NTCTS [defns.ntcts]. The value type shall be an encoded character
type. A function argument <tt class="docutils literal"><span class="pre">InputIterator</span> <span class="pre">begin</span></tt> shall have an
effective range [<tt class="docutils literal"><span class="pre">begin</span></tt>, <tt class="docutils literal"><span class="pre">end</span></tt>) where <tt class="docutils literal"><span class="pre">end</span></tt> is the first
iterator value with an element value equal to
<tt class="docutils literal"><span class="pre">iterator_traits&lt;InputIterator&gt;::value_type()</span></tt>.</li>
<li>A character array that after array-to-pointer decay results in a
pointer to a NTCTS. The value type shall be an encoded character
type. A function argument <tt class="docutils literal"><span class="pre">const</span> <span class="pre">Source&amp;</span> <span class="pre">source</span></tt> shall have an
effective range [source, end) where end is the first iterator value
with an element value equal to
<tt class="docutils literal"><span class="pre">iterator_traits&lt;decay&lt;Source&gt;::type&gt;::value_type()</span></tt>.</li>
</ul>
<p>Arguments of type <tt class="docutils literal"><span class="pre">Source</span></tt> shall not be null pointers.</p>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">This is similar wording to the filesystem path requirements in
N3963
(<a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3693.html#path-Requirements">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3693.html#path-Requirements</a>).</p>
</div>
<p>URI References returned by <tt class="docutils literal"><span class="pre">std::experimental::uri::make_relative</span></tt>
must be transformed by using the algorithm in IETF RFC 3986, section
5.2.2.</p>
<p>Removing dot segments (&#8221;.&#8221;, &#8221;..&#8221;) from a path must conform to IETF RFC
3986, section 5.2.4.</p>
</div>
<div class="section" id="typedef-s-class-uri-typedefs">
<h3>7.2 <tt class="docutils literal"><span class="pre">typedef</span></tt> s [class.uri.typedefs]<a class="headerlink" href="#typedef-s-class-uri-typedefs" title="Permalink to this headline">¶</a></h3>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">typedef</span> <span class="o">*</span><span class="n">unspecified</span><span class="o">*</span> <span class="n">string_type</span><span class="p">;</span>
<span class="k">typedef</span> <span class="o">*</span><span class="n">unspecified</span><span class="o">*</span> <span class="n">iterator</span><span class="p">;</span>
<span class="k">typedef</span> <span class="o">*</span><span class="n">unspecified</span><span class="o">*</span> <span class="n">const_iterator</span><span class="p">;</span>
<span class="k">typedef</span> <span class="n">std</span><span class="o">::</span><span class="n">iterator_traits</span><span class="o">&lt;</span><span class="n">iterator</span><span class="o">&gt;::</span><span class="n">value_type</span> <span class="n">value_type</span><span class="p">;</span>
<span class="k">typedef</span> <span class="n">basic_string_view</span><span class="o">&lt;</span><span class="n">value_type</span><span class="o">&gt;</span> <span class="n">string_view</span><span class="p">;</span>
</pre></div>
</div>
<p>The <tt class="docutils literal"><span class="pre">string_type</span></tt>, <tt class="docutils literal"><span class="pre">iterator</span></tt> and <tt class="docutils literal"><span class="pre">const_iterator</span></tt> types are
left <em>unspecified</em>.</p>
</div>
<div class="section" id="uri-members-class-uri-members">
<h3>7.3 <tt class="docutils literal"><span class="pre">uri</span></tt> members [class.uri.members]<a class="headerlink" href="#uri-members-class-uri-members" title="Permalink to this headline">¶</a></h3>
<div class="section" id="uri-constructors-class-uri-members-constructors">
<h4>7.3.1 <tt class="docutils literal"><span class="pre">uri</span></tt> constructors [class.uri.members.constructors]<a class="headerlink" href="#uri-constructors-class-uri-members-constructors" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri</span><span class="p">();</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs an object of class <tt class="docutils literal"><span class="pre">uri</span></tt>.</div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">empty()</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs a <tt class="docutils literal"><span class="pre">uri</span></tt> object with the underlying string
and parts copied.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri</span><span class="p">(</span><span class="n">uri</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs a <tt class="docutils literal"><span class="pre">uri</span></tt> object with the underlying string
and parts moved.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Allocator</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">allocator</span><span class="o">&lt;</span><span class="n">value_type</span><span class="o">&gt;&gt;</span>
<span class="n">uri</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">source</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span> <span class="o">=</span> <span class="n">Allocator</span><span class="p">());</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: The source is copied into the <tt class="docutils literal"><span class="pre">uri</span></tt> object and
parsed. The encoding is assumed to depend on the
underlying character type and implementation. All memory
allocation shall be performed by <tt class="docutils literal"><span class="pre">alloc</span></tt>.</div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">!empty()</span> <span class="pre">&amp;&amp;</span> <span class="pre">is_absolute()</span></tt></div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">uri_syntax_error</span></tt> if <tt class="docutils literal"><span class="pre">source</span></tt> is not a valid URI
string, <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">class</span> <span class="nc">Allocator</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">allocator</span><span class="o">&lt;</span><span class="n">value_type</span><span class="o">&gt;&gt;</span>
<span class="n">uri</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span> <span class="o">=</span> <span class="n">Allocator</span><span class="p">());</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: The source is copied into the <tt class="docutils literal"><span class="pre">uri</span></tt> object and
parsed. The encoding is assumed to depend on the
underlying character type and implementation. All memory
allocation shall be performed by <tt class="docutils literal"><span class="pre">alloc</span></tt>.</div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">!empty()</span> <span class="pre">&amp;&amp;</span> <span class="pre">is_absolute()</span></tt></div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">uri_syntax_error</span></tt> if the string in the range
[<tt class="docutils literal"><span class="pre">begin</span></tt>, <tt class="docutils literal"><span class="pre">end</span></tt>) is not a valid URI string,
<tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
</div>
<div class="section" id="uri-assignment-class-uri-members-assignment">
<h4>7.3.2 <tt class="docutils literal"><span class="pre">uri</span></tt> assignment [class.uri.members.assignment]<a class="headerlink" href="#uri-assignment-class-uri-members-assignment" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span> <span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Assigns a <tt class="docutils literal"><span class="pre">uri</span></tt> object with the underlying string
and parts copied.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: std::bad_alloc</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span> <span class="p">(</span><span class="n">uri</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Assigns a <tt class="docutils literal"><span class="pre">uri</span></tt> object with the underlying string
and parts moved.</div>
</div>
</div>
<div class="section" id="uri-modifiers-uri-members-modifiers">
<h4>7.3.3. <tt class="docutils literal"><span class="pre">uri</span></tt> modifiers [uri.members.modifiers]<a class="headerlink" href="#uri-modifiers-uri-members-modifiers" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="kt">void</span> <span class="n">swap</span><span class="p">(</span><span class="n">uri</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Swaps the contents of <tt class="docutils literal"><span class="pre">this</span></tt> object with the other.</div>
</div>
</div>
<div class="section" id="uri-iterators-uri-members-iterators">
<h4>7.3.4 <tt class="docutils literal"><span class="pre">uri</span></tt> iterators [uri.members.iterators]<a class="headerlink" href="#uri-iterators-uri-members-iterators" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">const_iterator</span> <span class="n">begin</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">const_iterator</span></tt> to the first element in the
underlying string container.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">const_iterator</span> <span class="n">end</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">const_iterator</span></tt> to the end of the underlying string
container.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">const_iterator</span> <span class="n">cbegin</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">const_iterator</span></tt> to the first element in the
underlying string container.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">const_iterator</span> <span class="n">cend</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">const_iterator</span></tt> to the end of the underlying string
container.</div>
</div>
</div>
<div class="section" id="uri-accessors-uri-members-accessors">
<h4>7.3.5 <tt class="docutils literal"><span class="pre">uri</span></tt> accessors [uri.members.accessors]<a class="headerlink" href="#uri-accessors-uri-members-accessors" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">scheme</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">std::optional&lt;string_view&gt;</span></tt> object which spans the
range of the scheme in the underlying URI. If the scheme
is not specified, it returns <tt class="docutils literal"><span class="pre">nullopt</span></tt>.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">user_info</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">std::optional&lt;string_view&gt;</span></tt> object which spans the
range of the user info in the underlying URI. If the user
info is not specified, it returns <tt class="docutils literal"><span class="pre">nullopt</span></tt>.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">host</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">std::optional&lt;string_view&gt;</span></tt> object which spans the
range of the host in the underlying URI. If the host
is not specified, it returns <tt class="docutils literal"><span class="pre">nullopt</span></tt>.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">port</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">std::optional&lt;string_view&gt;</span></tt> object which spans the
range of the port in the underlying URI. If the port
is not specified, it returns <tt class="docutils literal"><span class="pre">nullopt</span></tt>.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">IntT</span><span class="o">&gt;</span>
<span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">IntT</span><span class="o">&gt;</span> <span class="n">port</span><span class="p">(</span><span class="k">typename</span> <span class="n">std</span><span class="o">::</span><span class="n">is_integral</span><span class="o">&lt;</span><span class="n">IntT</span><span class="o">&gt;::</span><span class="n">type</span><span class="o">*</span> <span class="o">=</span> <span class="mi">0</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">std::optional&lt;IntT&gt;</span></tt> with the port value, if it is
present. If the port is not specified, it returns
<tt class="docutils literal"><span class="pre">nullopt</span></tt>.</div>
</div>
<div class="line-block">
<div class="line"><cite>Requires</cite>: <tt class="docutils literal"><span class="pre">is_integral&lt;IntT&gt;::value</span> <span class="pre">==</span> <span class="pre">true</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">path</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">std::optional&lt;string_view&gt;</span></tt> object which spans the
range of the path in the underlying URI. If the path
is not specified, it returns <tt class="docutils literal"><span class="pre">nullopt</span></tt>.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">authority</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">std::optional&lt;string_view&gt;</span></tt> object which spans the
range of the authority in the underlying URI. If the
authority is not specified, it returns <tt class="docutils literal"><span class="pre">nullopt</span></tt>.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">query</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">std::optional&lt;string_view&gt;</span></tt> object which spans the
range of the query in the underlying URI. If the query
is not specified, it returns <tt class="docutils literal"><span class="pre">nullopt</span></tt>.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">optional</span><span class="o">&lt;</span><span class="n">string_view</span><span class="o">&gt;</span> <span class="n">fragment</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A <tt class="docutils literal"><span class="pre">std::optional&lt;string_view&gt;</span></tt> object which spans the
range of the fragment in the underlying URI. If the
fragment is not specified, it returns <tt class="docutils literal"><span class="pre">nullopt</span></tt>.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">CharT</span><span class="p">,</span>
          <span class="k">class</span> <span class="nc">CharTraits</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">char_traits</span><span class="o">&lt;</span><span class="n">CharT</span><span class="o">&gt;</span><span class="p">,</span>
          <span class="k">class</span> <span class="nc">Allocator</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">allocator</span><span class="o">&lt;</span><span class="n">CharT</span><span class="o">&gt;&gt;</span>
<span class="n">std</span><span class="o">::</span><span class="n">basic_string</span><span class="o">&lt;</span><span class="n">CharT</span><span class="p">,</span> <span class="n">CharTraits</span><span class="p">,</span> <span class="n">Allocator</span><span class="o">&gt;</span>
<span class="n">to_string</span><span class="p">(</span><span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span> <span class="o">=</span> <span class="n">Allocator</span><span class="p">())</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A string object containing a copy of the underlying URI
string. All memory allocation shall be performed by
<tt class="docutils literal"><span class="pre">alloc</span></tt>.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">string</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A string object containing a copy of the underlying URI
string.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">wstring</span> <span class="n">wstring</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A wstring object containing a copy of the underlying URI
string.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">u8string</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A UTF-8 encoded string object containing a copy of the
underlying URI string.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">u16string</span> <span class="n">u16string</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A u16string object containing a copy of the underlying
URI string.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">u32string</span> <span class="n">u32string</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A u32string object containing a copy of the underlying
URI string.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
</div>
<div class="section" id="uri-query-uri-members-query">
<h4>7.3.6 <tt class="docutils literal"><span class="pre">uri</span></tt> query [uri.members.query]<a class="headerlink" href="#uri-query-uri-members-query" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="kt">bool</span> <span class="n">empty</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: <tt class="docutils literal"><span class="pre">true</span></tt> if the underlying string object is empty,
<tt class="docutils literal"><span class="pre">false</span></tt> otherwise.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="kt">bool</span> <span class="n">is_absolute</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: <tt class="docutils literal"><span class="pre">true</span></tt> if the URI is absolute. Equivalent to
<tt class="docutils literal"><span class="pre">!scheme().empty()</span></tt>.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="kt">bool</span> <span class="n">is_opaque</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: <tt class="docutils literal"><span class="pre">true</span></tt> if the URI is absolute and its scheme is not
hierarchical (i.e. the scheme-specific part does not
start with a double-slash &#8220;//&#8221; and its authority is
empty).</div>
</div>
</div>
<div class="section" id="uri-transformers-uri-members-transformers">
<h4>7.3.7 <tt class="docutils literal"><span class="pre">uri</span></tt> transformers [uri.members.transformers]<a class="headerlink" href="#uri-transformers-uri-members-transformers" title="Permalink to this headline">¶</a></h4>
<p>This proposal specifies three transformer functions: <tt class="docutils literal"><span class="pre">normalize</span></tt>,
<tt class="docutils literal"><span class="pre">make_relative</span></tt> and <tt class="docutils literal"><span class="pre">resolve</span></tt>.</p>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri</span> <span class="n">normalize</span><span class="p">(</span><span class="n">uri_normalization_level</span> <span class="n">level</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: <tt class="docutils literal"><span class="pre">normalize</span></tt> takes as an argument a <tt class="docutils literal"><span class="pre">uri</span></tt> object and
returns a normalized <tt class="docutils literal"><span class="pre">uri</span></tt> object.</div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">u.normalize(level).compare(u,</span> <span class="pre">level)</span> <span class="pre">==</span> <span class="pre">0</span></tt></div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">normalize</span><span class="p">(</span><span class="n">uri_normalization_level</span> <span class="n">level</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: <tt class="docutils literal"><span class="pre">normalize</span></tt> takes as an argument a <tt class="docutils literal"><span class="pre">uri</span></tt> object and
returns a normalized <tt class="docutils literal"><span class="pre">uri</span></tt> object. All memory
allocation shall be performed by <tt class="docutils literal"><span class="pre">alloc</span></tt>.</div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">u.normalize(level).compare(u,</span> <span class="pre">level)</span> <span class="pre">==</span> <span class="pre">0</span></tt></div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri</span> <span class="n">normalize</span><span class="p">(</span><span class="n">uri_normalization_level</span> <span class="n">level</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: <tt class="docutils literal"><span class="pre">normalize</span></tt> takes as an argument a <tt class="docutils literal"><span class="pre">uri</span></tt> object and
returns a normalized <tt class="docutils literal"><span class="pre">uri</span></tt> object. <tt class="docutils literal"><span class="pre">ec</span></tt> is set on
error and <tt class="docutils literal"><span class="pre">normalize</span></tt> returns an empty <tt class="docutils literal"><span class="pre">uri</span></tt>
object.</div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">ec</span> <span class="pre">||</span> <span class="pre">u.normalize(level).compare(u,</span> <span class="pre">level)</span> <span class="pre">==</span> <span class="pre">0</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">normalize</span><span class="p">(</span><span class="n">uri_normalization_level</span> <span class="n">level</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">,</span>
              <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: <tt class="docutils literal"><span class="pre">normalize</span></tt> takes as an argument a <tt class="docutils literal"><span class="pre">uri</span></tt> object and
returns a normalized <tt class="docutils literal"><span class="pre">uri</span></tt> object. All memory
allocation shall be performed by <tt class="docutils literal"><span class="pre">alloc</span></tt>. <tt class="docutils literal"><span class="pre">ec</span></tt> is set
on error and <tt class="docutils literal"><span class="pre">normalize</span></tt> returns an empty <tt class="docutils literal"><span class="pre">uri</span></tt>
object.</div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">ec</span> <span class="pre">||</span> <span class="pre">u.normalize(level).compare(u,</span> <span class="pre">level)</span> <span class="pre">==</span> <span class="pre">0</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri</span> <span class="n">make_relative</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Returns a relative URI reference against <tt class="docutils literal"><span class="pre">base</span></tt>. A
<tt class="docutils literal"><span class="pre">base_uri_error</span></tt> is thrown if <tt class="docutils literal"><span class="pre">base</span></tt> is a relative
reference.</div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">!u.make_relative(base).absolute()</span></tt></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A relative URI reference.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">make_relative</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Returns a relative URI reference against <tt class="docutils literal"><span class="pre">base</span></tt>. All
memory allocation shall be performed by <tt class="docutils literal"><span class="pre">alloc</span></tt>. A
<tt class="docutils literal"><span class="pre">base_uri_error</span></tt> is thrown if <tt class="docutils literal"><span class="pre">base</span></tt> is a relative
reference.</div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">!u.make_relative(base,</span> <span class="pre">alloc).absolute()</span></tt></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A relative URI reference.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri</span> <span class="n">make_relative</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Returns a relative URI reference against <tt class="docutils literal"><span class="pre">base</span></tt>. <tt class="docutils literal"><span class="pre">ec</span></tt>
is set on error.</div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A relative URI reference.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">make_relative</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span> <span class="o">&amp;</span><span class="n">alloc</span><span class="p">,</span>
                  <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Returns a relative URI reference against <tt class="docutils literal"><span class="pre">base</span></tt>. All
memory allocation shall be performed by <tt class="docutils literal"><span class="pre">alloc</span></tt>. <tt class="docutils literal"><span class="pre">ec</span></tt>
is set on error and <tt class="docutils literal"><span class="pre">make_relative</span></tt> returns an empty
<tt class="docutils literal"><span class="pre">uri</span></tt> object.</div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A relative URI reference.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri</span> <span class="n">resolve</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Pre-parses and normalizes <tt class="docutils literal"><span class="pre">resolve</span></tt> resolves against
<tt class="docutils literal"><span class="pre">base</span></tt> according to IETF RFC 3986, section 5.2.1, then
transforms the reference according to IETF 3986, section
5.2.2. The resolved <tt class="docutils literal"><span class="pre">uri</span></tt> object is returned. A
<tt class="docutils literal"><span class="pre">base_uri_error</span></tt> is thrown if <tt class="docutils literal"><span class="pre">base</span></tt> is invalid
(<a class="reference internal" href="index.html#uri-reference-and-resolution-errors"><em>13.2 URI Reference and Resolution Errors</em></a>).</div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">u.resolve(base).absolute()</span></tt></div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">resolve</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Pre-parses and normalizes <tt class="docutils literal"><span class="pre">resolve</span></tt> resolves against
<tt class="docutils literal"><span class="pre">base</span></tt> according to IETF RFC 3986, section 5.2.1, then
transforms the reference according to IETF 3986, section
5.2.2. The resolved <tt class="docutils literal"><span class="pre">uri</span></tt> object is returned. All
memory allocation shall be performed by <tt class="docutils literal"><span class="pre">alloc</span></tt>. A
<tt class="docutils literal"><span class="pre">base_uri_error</span></tt> is thrown if <tt class="docutils literal"><span class="pre">base</span></tt> is invalid
(<a class="reference internal" href="index.html#uri-reference-and-resolution-errors"><em>13.2 URI Reference and Resolution Errors</em></a>).</div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">u.resolve(base,</span> <span class="pre">alloc).absolute()</span></tt></div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri</span> <span class="n">resolve</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Pre-parses and normalizes <tt class="docutils literal"><span class="pre">resolve</span></tt> resolves against
<tt class="docutils literal"><span class="pre">base</span></tt> according to IETF RFC 3986, section 5.2.1, then
transforms the reference according to IETF 3986, section
5.2.2. The resolved <tt class="docutils literal"><span class="pre">uri</span></tt> object is returned. <tt class="docutils literal"><span class="pre">ec</span></tt> is
set on error and <tt class="docutils literal"><span class="pre">resolve</span></tt> returns an empty <tt class="docutils literal"><span class="pre">uri</span></tt>
object.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Allocator</span><span class="o">&gt;</span>
<span class="n">uri</span> <span class="n">resolve</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">,</span> <span class="k">const</span> <span class="n">Allocator</span><span class="o">&amp;</span> <span class="n">alloc</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">error_code</span><span class="o">&amp;</span> <span class="n">ec</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Pre-parses and normalizes <tt class="docutils literal"><span class="pre">resolve</span></tt> resolves against
<tt class="docutils literal"><span class="pre">base</span></tt> according to IETF RFC 3986, section 5.2.1, then
transforms the reference according to IETF 3986, section
5.2.2. The resolved <tt class="docutils literal"><span class="pre">uri</span></tt> object is returned. All
memory allocation shall be performed by <tt class="docutils literal"><span class="pre">alloc</span></tt>. <tt class="docutils literal"><span class="pre">ec</span></tt>
is set on error and <tt class="docutils literal"><span class="pre">resolve</span></tt>.  returns an empty
<tt class="docutils literal"><span class="pre">uri</span></tt> object</div>
</div>
</div>
<div class="section" id="uri-comparison-uri-members-comparison">
<h4>7.3.8 <tt class="docutils literal"><span class="pre">uri</span></tt> comparison [uri.members.comparison]<a class="headerlink" href="#uri-comparison-uri-members-comparison" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="kt">int</span> <span class="n">compare</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">,</span> <span class="n">uri_normalization_level</span> <span class="n">level</span><span class="p">)</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Equivalent to <tt class="docutils literal"><span class="pre">normalize(level)</span> <span class="pre">==</span> <span class="pre">other.normalize(level)</span></tt></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: -1 if the normalized value of this is lexicographically
less than the normalized value <tt class="docutils literal"><span class="pre">other</span></tt>, given the
comparison <tt class="docutils literal"><span class="pre">level</span></tt>; 0 if they are considered equal and
1 if this is greater.</div>
</div>
</div>
<div class="section" id="uri-percent-encoding-uri-members-percent">
<h4>7.3.9 <tt class="docutils literal"><span class="pre">uri</span></tt> percent encoding [uri.members.percent]<a class="headerlink" href="#uri-percent-encoding-uri-members-percent" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
<span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_user_info</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                       <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Encodes special characters for the user_info part (IETF
RFC 3986, section 2.1).</div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: An iterator to the last element of a <tt class="docutils literal"><span class="pre">user_info</span></tt> string
that has been encoded.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
<span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_host</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                  <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Encodes special characters for the host part (IETF RFC
3986, section 2.1).</div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: An iterator to the last element of a <tt class="docutils literal"><span class="pre">host</span></tt> string that
has been encoded.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
<span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_port</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                  <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Encodes special characters for the port part (IETF RFC 3986,
section 2.1).</div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: An iterator to the last element of a <tt class="docutils literal"><span class="pre">port</span></tt> string that
has been encoded.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
<span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_path</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                  <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Encodes special characters for the path part (IETF RFC 3986,
section 2.1).</div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: An iterator to the last element of a <tt class="docutils literal"><span class="pre">path</span></tt> string that
has been encoded.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
<span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_query</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                   <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Encodes special characters for the query part (IETF RFC 3986,
section 2.1).</div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: An iterator to the last element of a <tt class="docutils literal"><span class="pre">query</span></tt> string that
has been encoded.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
<span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">encode_fragment</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                                      <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Encodes special characters for the fragment part (IETF RFC 3986,
section 2.1).</div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: An iterator to the last element of a <tt class="docutils literal"><span class="pre">fragment</span></tt> string that
has been encoded.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">InputIterator</span><span class="p">,</span> <span class="k">typename</span> <span class="n">OutputIterator</span><span class="o">&gt;</span>
<span class="k">static</span> <span class="n">OutputIterator</span> <span class="n">decode</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">,</span>
                             <span class="n">OutputIterator</span> <span class="n">out</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Decodes special characters in the source string and
returns the unencoded string (IETF RFC 3986, section 2.1)</div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: An iterator to the last element of a <tt class="docutils literal"><span class="pre">uri</span></tt> string that
has been decoded.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">uri_decoding_error</span></tt> when the input is exhausted, the
input is not a hexadecimal character or when the decoding
conversion fails.</div>
</div>
</div>
</div>
</div>
<span id="document-class_uri_builder"></span><div class="section" id="class-uri-builder-class-uri-builder">
<span id="class-uri-builder"></span><h2>8 Class <tt class="docutils literal"><span class="pre">uri_builder</span></tt> [class.uri_builder]<a class="headerlink" href="#class-uri-builder-class-uri-builder" title="Permalink to this headline">¶</a></h2>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="k">class</span> <span class="nc">uri_builder</span> <span class="p">{</span>

<span class="k">public</span><span class="o">:</span>

    <span class="c1">// constructors and destructor</span>
    <span class="n">uri_builder</span><span class="p">();</span>
    <span class="k">explicit</span> <span class="n">uri_builder</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
    <span class="k">explicit</span> <span class="n">uri_builder</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
    <span class="n">uri_builder</span><span class="p">(</span><span class="k">const</span> <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">);</span>
    <span class="n">uri_builder</span><span class="p">(</span><span class="n">uri_builder</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
    <span class="o">~</span><span class="n">uri_builder</span><span class="p">();</span>

    <span class="c1">// assignment</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="k">operator</span> <span class="o">=</span> <span class="n">uri_builder</span><span class="p">(</span><span class="k">const</span> <span class="n">uri_builder</span><span class="o">&amp;</span><span class="p">);</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="k">operator</span> <span class="o">=</span> <span class="n">uri_builder</span><span class="p">(</span><span class="n">uri_builder</span><span class="o">&amp;&amp;</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>

    <span class="c1">// modifiers</span>
    <span class="kt">void</span> <span class="n">swap</span><span class="p">(</span><span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>

    <span class="c1">// setters</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">scheme</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">scheme</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">scheme</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">user_info</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">user_info</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">user_info</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">host</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">host</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">host</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">port</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">port</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">port</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">authority</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">authority</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">authority</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">UserInfoSource</span><span class="p">,</span> <span class="k">class</span> <span class="nc">HostSource</span><span class="p">,</span> <span class="n">PortSource</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">authority</span><span class="p">(</span><span class="k">const</span> <span class="n">UserInfoSource</span><span class="o">&amp;</span> <span class="n">user_info</span><span class="p">,</span>
                           <span class="k">const</span> <span class="n">HostSource</span><span class="o">&amp;</span> <span class="n">host</span><span class="p">,</span> <span class="k">const</span> <span class="n">PortSource</span><span class="o">&amp;</span> <span class="n">port</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">path</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">path</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">path</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">append_path</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">path</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">append_path</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">query</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">query</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">query</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">KeySource</span><span class="p">,</span> <span class="k">class</span> <span class="nc">ParamSource</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">append_query</span><span class="p">(</span><span class="k">const</span> <span class="n">KeySource</span><span class="o">&amp;</span> <span class="n">key</span><span class="p">,</span> <span class="k">const</span> <span class="n">ParamSource</span><span class="o">&amp;</span> <span class="n">param</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">fragment</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">fragment</span><span class="p">);</span>
    <span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
    <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">fragment</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>

    <span class="c1">// builder</span>
    <span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">uri</span> <span class="n">uri</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>

<span class="p">};</span>
<span class="p">}</span> <span class="c1">// namespace experimental</span>
<span class="p">}</span> <span class="c1">// namespace std</span>
</pre></div>
</div>
<div class="section" id="uri-builder-requirements-class-uri-builder-requirements">
<h3>8.1 <tt class="docutils literal"><span class="pre">uri_builder</span></tt> requirements [class.uri_builder.requirements]<a class="headerlink" href="#uri-builder-requirements-class-uri-builder-requirements" title="Permalink to this headline">¶</a></h3>
<p>Function template parameters named <tt class="docutils literal"><span class="pre">Source</span></tt> shall be one of:</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">basic_string&lt;CharT,</span> <span class="pre">CharTraits,</span> <span class="pre">Allocator&gt;</span></tt>. The type charT shall
be an encoded character type.  A function argument <tt class="docutils literal"><span class="pre">const</span> <span class="pre">Source&amp;</span>
<span class="pre">source</span></tt> shall have an effective range [<tt class="docutils literal"><span class="pre">cbegin(source)</span></tt>,
<tt class="docutils literal"><span class="pre">cend(source)</span></tt>).</li>
<li><tt class="docutils literal"><span class="pre">basic_string_view&lt;CharT,</span> <span class="pre">CharTraits&gt;</span></tt>. The type charT shall be an
encoded character type.  A function argument <tt class="docutils literal"><span class="pre">const</span> <span class="pre">Source&amp;</span>
<span class="pre">source</span></tt> shall have an effective range [<tt class="docutils literal"><span class="pre">cbegin(source)</span></tt>,
<tt class="docutils literal"><span class="pre">cend(source)</span></tt>).</li>
<li>A type meeting the input iterator requirements that iterates over a
NTCTS [defns.ntcts]. The value type shall be an encoded character
type. A function argument <tt class="docutils literal"><span class="pre">InputIterator</span> <span class="pre">begin</span></tt> shall have an
effective range [<tt class="docutils literal"><span class="pre">begin</span></tt>, <tt class="docutils literal"><span class="pre">end</span></tt>) where <tt class="docutils literal"><span class="pre">end</span></tt> is the first
iterator value with an element value equal to
<tt class="docutils literal"><span class="pre">iterator_traits&lt;InputIterator&gt;::value_type()</span></tt>.</li>
<li>A type that be convertible to
<tt class="docutils literal"><span class="pre">std::experimental::uri::string_type</span></tt> by a means that can be
chosen by the implementation.</li>
</ul>
<p>Arguments of type <tt class="docutils literal"><span class="pre">Source</span></tt> shall not be null pointers.</p>
<p>The URI must be built according to component recomposition rules in
IETF RFC 3986, section 5.3.</p>
</div>
<div class="section" id="uri-builder-constructors-class-uri-builder-constructors">
<h3>8.2 <tt class="docutils literal"><span class="pre">uri_builder</span></tt> constructors [class.uri_builder.constructors]<a class="headerlink" href="#uri-builder-constructors-class-uri-builder-constructors" title="Permalink to this headline">¶</a></h3>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri_builder</span><span class="p">();</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs a <tt class="docutils literal"><span class="pre">uri_builder</span></tt> object.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri_builder</span><span class="p">(</span><span class="k">const</span> <span class="n">uri</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs a <tt class="docutils literal"><span class="pre">uri_builder</span></tt> object from a base URI.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">base</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs a <tt class="docutils literal"><span class="pre">uri_builder</span></tt> object from a base URI.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri_builder</span><span class="p">(</span><span class="k">const</span> <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs a <tt class="docutils literal"><span class="pre">uri_builder</span></tt> object with the underlying
parts copied.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt></div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri_builder</span><span class="p">(</span><span class="n">uri_builder</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Constructs a <tt class="docutils literal"><span class="pre">uri_builder</span></tt> object with the underlying
parts moved.</div>
</div>
</div>
<div class="section" id="uri-builder-assignment-class-uri-builder-members-assignment">
<h3>8.3 <tt class="docutils literal"><span class="pre">uri_builder</span></tt> assignment [class. uri_builder.members.assignment]<a class="headerlink" href="#uri-builder-assignment-class-uri-builder-members-assignment" title="Permalink to this headline">¶</a></h3>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri_builder</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span> <span class="p">(</span><span class="k">const</span> <span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Assigns a <tt class="docutils literal"><span class="pre">uri_builder</span></tt> object with the underlying
string and parts copied.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: std::bad_alloc</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri_builder</span><span class="o">&amp;</span> <span class="k">operator</span><span class="o">=</span> <span class="p">(</span><span class="n">uri_builder</span><span class="o">&amp;&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Assigns a <tt class="docutils literal"><span class="pre">uri_builder</span></tt> object with the underlying
string and parts moved.</div>
</div>
</div>
<div class="section" id="uri-builder-members-class-uri-builder-members">
<h3>8.4 <tt class="docutils literal"><span class="pre">uri_builder</span></tt> members [class.uri_builder.members]<a class="headerlink" href="#uri-builder-members-class-uri-builder-members" title="Permalink to this headline">¶</a></h3>
<div class="highlight-c++"><div class="highlight"><pre><span class="kt">void</span> <span class="n">swap</span><span class="p">(</span><span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">other</span><span class="p">)</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Swaps the contents of <tt class="docutils literal"><span class="pre">this</span></tt> object with the other.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">scheme</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">scheme</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">scheme</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Sets the URI scheme.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">user_info</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">user_info</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">user_info</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Sets the URI user_info.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">host</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">host</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">host</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Sets the URI host.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">port</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">port</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">port</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Sets the URI port.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">authority</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">authority</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">authority</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Sets the URI authority.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">UserInfoSource</span><span class="p">,</span> <span class="k">class</span> <span class="nc">HostSource</span><span class="p">,</span> <span class="k">class</span> <span class="nc">PortSource</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">authority</span><span class="p">(</span><span class="k">const</span> <span class="n">UserInfoSource</span><span class="o">&amp;</span> <span class="n">user_info</span><span class="p">,</span>
                       <span class="k">const</span> <span class="n">HostSource</span><span class="o">&amp;</span> <span class="n">host</span><span class="p">,</span> <span class="k">const</span> <span class="n">PortSource</span><span class="o">&amp;</span> <span class="n">port</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Sets the URI user info, host and port.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">path</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">path</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">path</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Sets the URI path.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">append_path</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">path</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">append_path</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Appends an element to the <tt class="docutils literal"><span class="pre">uri</span></tt> object&#8217;s path.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">query</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">query</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">query</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Sets the URI query.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">KeySource</span><span class="p">,</span> <span class="k">class</span> <span class="nc">ParamSource</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">append_query</span><span class="p">(</span><span class="k">const</span> <span class="n">KeySource</span><span class="o">&amp;</span> <span class="n">key</span><span class="p">,</span> <span class="k">const</span> <span class="n">ParamSource</span><span class="o">&amp;</span> <span class="n">param</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Appends a key-value pair to the <tt class="docutils literal"><span class="pre">uri</span></tt> object&#8217;s query.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">Source</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">fragment</span><span class="p">(</span><span class="k">const</span> <span class="n">Source</span><span class="o">&amp;</span> <span class="n">fragment</span><span class="p">);</span>
<span class="k">template</span> <span class="o">&lt;</span><span class="k">class</span> <span class="nc">InputIterator</span><span class="o">&gt;</span>
<span class="n">uri_builder</span><span class="o">&amp;</span> <span class="n">fragment</span><span class="p">(</span><span class="n">InputIterator</span> <span class="n">begin</span><span class="p">,</span> <span class="n">InputIterator</span> <span class="n">end</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Sets the URI fragment.</div>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">std</span><span class="o">::</span><span class="n">experimental</span><span class="o">::</span><span class="n">uri</span> <span class="n">uri</span><span class="p">()</span> <span class="k">const</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Effects</cite>: Builds a URI object from the provided parts. A URI built
using this method should be normalized according to
syntax-based normalization. This includes case
normalization, percent-encoding normalization, character
normalization and path segment normalization.</div>
</div>
<div class="line-block">
<div class="line"><cite>Throws</cite>: <tt class="docutils literal"><span class="pre">std::bad_alloc</span></tt>, or <tt class="docutils literal"><span class="pre">uri_builder_error</span></tt> if any of the
parts are invalid and a valid uri cannot be formed.</div>
</div>
</div>
</div>
<span id="document-class_uri_syntax_error"></span><div class="section" id="class-uri-syntax-error-class-uri-syntax-error">
<span id="uri-syntax-error"></span><h2>9 Class <tt class="docutils literal"><span class="pre">uri_syntax_error</span></tt> [class.uri_syntax_error]<a class="headerlink" href="#class-uri-syntax-error-class-uri-syntax-error" title="Permalink to this headline">¶</a></h2>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="k">class</span> <span class="nc">uri_syntax_error</span> <span class="o">:</span> <span class="k">public</span> <span class="n">std</span><span class="o">::</span><span class="n">system_error</span> <span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
    <span class="n">uri_syntax_error</span><span class="p">(</span><span class="k">const</span> <span class="n">string</span><span class="o">&amp;</span> <span class="n">what_arg</span><span class="p">,</span> <span class="n">error_code</span> <span class="n">ec</span><span class="p">);</span>
    <span class="k">virtual</span> <span class="o">~</span><span class="n">uri_syntax_error</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
    <span class="k">virtual</span> <span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">what</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="p">};</span>
<span class="p">}</span> <span class="c1">// namespace experimental</span>
<span class="p">}</span> <span class="c1">// namespace std</span>
</pre></div>
</div>
<div class="section" id="uri-syntax-error-members-class-uri-syntax-error-members">
<h3>9.1 <tt class="docutils literal"><span class="pre">uri_syntax_error</span></tt> members [class.uri_syntax_error.members]<a class="headerlink" href="#uri-syntax-error-members-class-uri-syntax-error-members" title="Permalink to this headline">¶</a></h3>
<div class="section" id="uri-syntax-error-constructors-class-uri-syntax-error-constructors">
<h4>9.1.1 <tt class="docutils literal"><span class="pre">uri_syntax_error</span></tt> constructors [class.uri_syntax_error.constructors]<a class="headerlink" href="#uri-syntax-error-constructors-class-uri-syntax-error-constructors" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri_syntax_error</span><span class="p">(</span><span class="k">const</span> <span class="n">string</span><span class="o">&amp;</span> <span class="n">what_arg</span><span class="p">,</span> <span class="n">error_code</span> <span class="n">ec</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">what()</span> <span class="pre">==</span> <span class="pre">what_arg.c_str()</span> <span class="pre">&amp;&amp;</span> <span class="pre">code()</span> <span class="pre">==</span> <span class="pre">ec</span></tt></div>
</div>
</div>
<div class="section" id="uri-syntax-error-accessors-class-uri-syntax-error-accessors">
<h4>9.1.2 <tt class="docutils literal"><span class="pre">uri_syntax_error</span></tt> accessors [class.uri_syntax_error.accessors]<a class="headerlink" href="#uri-syntax-error-accessors-class-uri-syntax-error-accessors" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">what</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A string containing the message in the string passed as
<tt class="docutils literal"><span class="pre">what_arg</span></tt> to the class constructor.</div>
</div>
</div>
</div>
</div>
<span id="document-class_base_uri_error"></span><div class="section" id="class-base-uri-error-class-base-uri-error">
<span id="base-uri-error"></span><h2>10 Class <tt class="docutils literal"><span class="pre">base_uri_error</span></tt> [class.base_uri_error]<a class="headerlink" href="#class-base-uri-error-class-base-uri-error" title="Permalink to this headline">¶</a></h2>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="k">class</span> <span class="nc">base_uri_error</span> <span class="o">:</span> <span class="k">public</span> <span class="n">std</span><span class="o">::</span><span class="n">system_error</span> <span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
    <span class="n">base_uri_error</span><span class="p">(</span><span class="k">const</span> <span class="n">string</span><span class="o">&amp;</span> <span class="n">what_arg</span><span class="p">,</span> <span class="n">error_code</span> <span class="n">ec</span><span class="p">);</span>
    <span class="k">virtual</span> <span class="o">~</span><span class="n">base_uri_error</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
    <span class="k">virtual</span> <span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">what</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="p">};</span>
<span class="p">}</span> <span class="c1">// namespace experimental</span>
<span class="p">}</span> <span class="c1">// namespace std</span>
</pre></div>
</div>
<div class="section" id="base-uri-error-members-class-base-uri-error-members">
<h3>10.1 <tt class="docutils literal"><span class="pre">base_uri_error</span></tt> members [class.base_uri_error.members]<a class="headerlink" href="#base-uri-error-members-class-base-uri-error-members" title="Permalink to this headline">¶</a></h3>
<div class="section" id="base-uri-error-constructors-class-base-uri-error-constructors">
<h4>10.1.1 <tt class="docutils literal"><span class="pre">base_uri_error</span></tt> constructors [class.base_uri_error.constructors]<a class="headerlink" href="#base-uri-error-constructors-class-base-uri-error-constructors" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">base_uri_error</span><span class="p">(</span><span class="k">const</span> <span class="n">string</span><span class="o">&amp;</span> <span class="n">what_arg</span><span class="p">,</span> <span class="n">error_code</span> <span class="n">ec</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">what()</span> <span class="pre">==</span> <span class="pre">what_arg.c_str()</span> <span class="pre">&amp;&amp;</span> <span class="pre">code()</span> <span class="pre">==</span> <span class="pre">ec</span></tt></div>
</div>
</div>
<div class="section" id="base-uri-error-accessors-class-base-uri-error-accessors">
<h4>10.1.2 <tt class="docutils literal"><span class="pre">base_uri_error</span></tt> accessors [class.base_uri_error.accessors]<a class="headerlink" href="#base-uri-error-accessors-class-base-uri-error-accessors" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">what</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A string containing the message in the string passed as
<tt class="docutils literal"><span class="pre">what_arg</span></tt> to the class constructor.</div>
</div>
</div>
</div>
</div>
<span id="document-class_uri_builder_error"></span><div class="section" id="class-uri-builder-error-class-uri-builder-error">
<span id="uri-builder-error"></span><h2>11 Class <tt class="docutils literal"><span class="pre">uri_builder_error</span></tt> [class.uri_builder_error]<a class="headerlink" href="#class-uri-builder-error-class-uri-builder-error" title="Permalink to this headline">¶</a></h2>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="k">class</span> <span class="nc">uri_builder_error</span> <span class="o">:</span> <span class="k">public</span> <span class="n">std</span><span class="o">::</span><span class="n">system_error</span> <span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
    <span class="n">uri_builder_error</span><span class="p">(</span><span class="k">const</span> <span class="n">string</span><span class="o">&amp;</span> <span class="n">what_arg</span><span class="p">,</span> <span class="n">error_code</span> <span class="n">ec</span><span class="p">);</span>
    <span class="k">virtual</span> <span class="o">~</span><span class="n">uri_builder_error</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
    <span class="k">virtual</span> <span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">what</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="p">};</span>
<span class="p">}</span> <span class="c1">// namespace experimental</span>
<span class="p">}</span> <span class="c1">// namespace std</span>
</pre></div>
</div>
<div class="section" id="uri-builder-error-members-class-uri-builder-error-members">
<h3>11.1 <tt class="docutils literal"><span class="pre">uri_builder_error</span></tt> members [class.uri_builder_error.members]<a class="headerlink" href="#uri-builder-error-members-class-uri-builder-error-members" title="Permalink to this headline">¶</a></h3>
<div class="section" id="uri-builder-error-constructors-class-uri-builder-error-constructors">
<h4>11.1.1 <tt class="docutils literal"><span class="pre">uri_builder_error</span></tt> constructors [class.uri_builder_error.constructors]<a class="headerlink" href="#uri-builder-error-constructors-class-uri-builder-error-constructors" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">uri_builder_error</span><span class="p">(</span><span class="k">const</span> <span class="n">string</span><span class="o">&amp;</span> <span class="n">what_arg</span><span class="p">,</span> <span class="n">error_code</span> <span class="n">ec</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">what()</span> <span class="pre">==</span> <span class="pre">what_arg.c_str()</span> <span class="pre">&amp;&amp;</span> <span class="pre">code()</span> <span class="pre">==</span> <span class="pre">ec</span></tt></div>
</div>
</div>
<div class="section" id="uri-builder-error-accessors-class-uri-builder-error-accessors">
<h4>11.1.2 <tt class="docutils literal"><span class="pre">uri_builder_error</span></tt> accessors [class.uri_builder_error.accessors]<a class="headerlink" href="#uri-builder-error-accessors-class-uri-builder-error-accessors" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">what</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A string containing the message in the string passed as
<tt class="docutils literal"><span class="pre">what_arg</span></tt> to the class constructor.</div>
</div>
</div>
</div>
</div>
<span id="document-class_percent_decoding_error"></span><div class="section" id="class-percent-decoding-error-class-percent-decoding-error">
<span id="percent-decoding-error"></span><h2>12 Class <tt class="docutils literal"><span class="pre">percent_decoding_error</span></tt> [class.percent_decoding_error]<a class="headerlink" href="#class-percent-decoding-error-class-percent-decoding-error" title="Permalink to this headline">¶</a></h2>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">namespace</span> <span class="n">std</span> <span class="p">{</span>
<span class="k">namespace</span> <span class="n">experimental</span> <span class="p">{</span>
<span class="k">class</span> <span class="nc">percent_decoding_error</span> <span class="o">:</span> <span class="k">public</span> <span class="n">std</span><span class="o">::</span><span class="n">system_error</span> <span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
    <span class="n">percent_decoding_error</span><span class="p">(</span><span class="k">const</span> <span class="n">string</span><span class="o">&amp;</span> <span class="n">what_arg</span><span class="p">,</span> <span class="n">error_code</span> <span class="n">ec</span><span class="p">);</span>
    <span class="k">virtual</span> <span class="o">~</span><span class="n">percent_decoding_error</span><span class="p">()</span> <span class="n">noexcept</span><span class="p">;</span>
    <span class="k">virtual</span> <span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">what</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
<span class="p">};</span>
<span class="p">}</span> <span class="c1">// namespace experimental</span>
<span class="p">}</span> <span class="c1">// namespace std</span>
</pre></div>
</div>
<div class="section" id="percent-decoding-error-members-class-percent-decoding-error-members">
<h3>12.1 <tt class="docutils literal"><span class="pre">percent_decoding_error</span></tt> members [class.percent_decoding_error.members]<a class="headerlink" href="#percent-decoding-error-members-class-percent-decoding-error-members" title="Permalink to this headline">¶</a></h3>
<div class="section" id="percent-decoding-error-constructors-class-percent-decoding-error-constructors">
<h4>12.1.1 <tt class="docutils literal"><span class="pre">percent_decoding_error</span></tt> constructors [class.percent_decoding_error.constructors]<a class="headerlink" href="#percent-decoding-error-constructors-class-percent-decoding-error-constructors" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="n">percent_decoding_error</span><span class="p">(</span><span class="k">const</span> <span class="n">string</span><span class="o">&amp;</span> <span class="n">what_arg</span><span class="p">,</span> <span class="n">error_code</span> <span class="n">ec</span><span class="p">);</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Postconditions</cite>: <tt class="docutils literal"><span class="pre">what()</span> <span class="pre">==</span> <span class="pre">what_arg.c_str()</span> <span class="pre">&amp;&amp;</span> <span class="pre">code()</span> <span class="pre">==</span> <span class="pre">ec</span></tt></div>
</div>
</div>
<div class="section" id="percent-decoding-error-accessors-class-percent-decoding-error-accessors">
<h4>12.1.2 <tt class="docutils literal"><span class="pre">percent_decoding_error</span></tt> accessors [class.percent_decoding_error.accessors]<a class="headerlink" href="#percent-decoding-error-accessors-class-percent-decoding-error-accessors" title="Permalink to this headline">¶</a></h4>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">what</span><span class="p">()</span> <span class="k">const</span> <span class="n">noexcept</span><span class="p">;</span>
</pre></div>
</div>
<div class="line-block">
<div class="line"><cite>Returns</cite>: A string containing the message in the string passed as
<tt class="docutils literal"><span class="pre">what_arg</span></tt> to the class constructor.</div>
</div>
</div>
</div>
</div>
<span id="document-class_uri_error"></span><div class="section" id="enum-class-uri-error-class-uri-error">
<span id="uri-error"></span><h2>13 Enum class <tt class="docutils literal"><span class="pre">uri_error</span></tt> [class.uri_error]<a class="headerlink" href="#enum-class-uri-error-class-uri-error" title="Permalink to this headline">¶</a></h2>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">enum</span> <span class="k">class</span> <span class="nc">uri_error</span> <span class="p">{</span>
 <span class="c1">// uri syntax errors</span>
 <span class="n">invalid_syntax</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span>

 <span class="c1">// uri relative reference and resolution errors</span>
 <span class="n">base_uri_is_empty</span><span class="p">,</span>
 <span class="n">base_uri_is_not_absolute</span><span class="p">,</span>
 <span class="n">base_uri_is_opaque</span><span class="p">,</span>
 <span class="n">base_uri_does_not_match</span><span class="p">,</span>

 <span class="c1">// builder errors</span>
 <span class="n">invalid_uri</span><span class="p">,</span>
 <span class="n">invalid_scheme</span><span class="p">,</span>
 <span class="n">invalid_user_info</span><span class="p">,</span>
 <span class="n">invalid_host</span><span class="p">,</span>
 <span class="n">invalid_port</span><span class="p">,</span>
 <span class="n">invalid_path</span><span class="p">,</span>
 <span class="n">invalid_query</span><span class="p">,</span>
 <span class="n">invalid_fragment</span><span class="p">,</span>

 <span class="c1">// decoding errors</span>
 <span class="n">not_enough_input</span><span class="p">,</span>
 <span class="n">non_hex_input</span><span class="p">,</span>
 <span class="n">conversion_failed</span><span class="p">,</span>
<span class="p">};</span>
</pre></div>
</div>
<div class="section" id="uri-syntax-errors">
<h3>13.1 URI Syntax Errors<a class="headerlink" href="#uri-syntax-errors" title="Permalink to this headline">¶</a></h3>
<div class="section" id="invalid-syntax">
<h4>13.1.1 <tt class="docutils literal"><span class="pre">invalid_syntax</span></tt><a class="headerlink" href="#invalid-syntax" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the parser is unable to parse the given URI
string.</p>
</div>
</div>
<div class="section" id="uri-reference-and-resolution-errors">
<span id="id1"></span><h3>13.2 URI Reference and Resolution Errors<a class="headerlink" href="#uri-reference-and-resolution-errors" title="Permalink to this headline">¶</a></h3>
<div class="section" id="base-uri-is-empty">
<h4>13.2.1 <tt class="docutils literal"><span class="pre">base_uri_is_empty</span></tt><a class="headerlink" href="#base-uri-is-empty" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the base URI passed to <tt class="docutils literal"><span class="pre">make_relative</span></tt> or
<tt class="docutils literal"><span class="pre">resolve</span></tt> is empty.</p>
</div>
<div class="section" id="base-uri-is-not-absolute">
<h4>13.2.2 <tt class="docutils literal"><span class="pre">base_uri_is_not_absolute</span></tt><a class="headerlink" href="#base-uri-is-not-absolute" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the base URI passed to <tt class="docutils literal"><span class="pre">make_relative</span></tt> or
<tt class="docutils literal"><span class="pre">resolve</span></tt> is not absolute (it is itself a relative reference).</p>
</div>
<div class="section" id="base-uri-is-opaque">
<h4>13.2.3 <tt class="docutils literal"><span class="pre">base_uri_is_opaque</span></tt><a class="headerlink" href="#base-uri-is-opaque" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the base URI passed to <tt class="docutils literal"><span class="pre">make_relative</span></tt> or
<tt class="docutils literal"><span class="pre">resolve</span></tt> is opaque.</p>
</div>
<div class="section" id="base-uri-does-not-match">
<h4>13.2.4 <tt class="docutils literal"><span class="pre">base_uri_does_not_match</span></tt><a class="headerlink" href="#base-uri-does-not-match" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the base URI passed to <tt class="docutils literal"><span class="pre">make_relative</span></tt> does
not match the prefix of the URI.</p>
</div>
</div>
<div class="section" id="uri-builder-errors">
<h3>13.3 URI Builder Errors<a class="headerlink" href="#uri-builder-errors" title="Permalink to this headline">¶</a></h3>
<div class="section" id="invalid-uri">
<h4>13.3.1 <tt class="docutils literal"><span class="pre">invalid_uri</span></tt><a class="headerlink" href="#invalid-uri" title="Permalink to this headline">¶</a></h4>
<p>This error is set in the <tt class="docutils literal"><span class="pre">uri_builder</span></tt> when the builder is unable to
construct a valid URI.</p>
</div>
<div class="section" id="invalid-scheme">
<h4>13.3.2 <tt class="docutils literal"><span class="pre">invalid_scheme</span></tt><a class="headerlink" href="#invalid-scheme" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the <tt class="docutils literal"><span class="pre">uri_builder</span></tt> if the scheme provided is
invalid.</p>
</div>
<div class="section" id="invalid-user-info">
<h4>13.3.3 <tt class="docutils literal"><span class="pre">invalid_user_info</span></tt><a class="headerlink" href="#invalid-user-info" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the <tt class="docutils literal"><span class="pre">uri_builder</span></tt> if the user info provided
is invalid.</p>
</div>
<div class="section" id="invalid-host">
<h4>13.3.4 <tt class="docutils literal"><span class="pre">invalid_host</span></tt><a class="headerlink" href="#invalid-host" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the <tt class="docutils literal"><span class="pre">uri_builder</span></tt> if the host provided is
invalid.</p>
</div>
<div class="section" id="invalid-port">
<h4>13.3.5 <tt class="docutils literal"><span class="pre">invalid_port</span></tt><a class="headerlink" href="#invalid-port" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the <tt class="docutils literal"><span class="pre">uri_builder</span></tt> if the port provided is
invalid.</p>
</div>
<div class="section" id="invalid-path">
<h4>13.3.6 <tt class="docutils literal"><span class="pre">invalid_path</span></tt><a class="headerlink" href="#invalid-path" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the <tt class="docutils literal"><span class="pre">uri_builder</span></tt> if the path provided is
invalid.</p>
</div>
<div class="section" id="invalid-query">
<h4>13.3.7 <tt class="docutils literal"><span class="pre">invalid_query</span></tt><a class="headerlink" href="#invalid-query" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the <tt class="docutils literal"><span class="pre">uri_builder</span></tt> if the query provided is
invalid.</p>
</div>
<div class="section" id="invalid-fragment">
<h4>13.3.8 <tt class="docutils literal"><span class="pre">invalid_fragment</span></tt><a class="headerlink" href="#invalid-fragment" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the <tt class="docutils literal"><span class="pre">uri_builder</span></tt> if the fragment provided is
invalid.</p>
</div>
</div>
<div class="section" id="percent-decoding-errors">
<h3>13.4 Percent Decoding Errors<a class="headerlink" href="#percent-decoding-errors" title="Permalink to this headline">¶</a></h3>
<div class="section" id="not-enough-input">
<h4>13.4.1 <tt class="docutils literal"><span class="pre">not_enough_input</span></tt><a class="headerlink" href="#not-enough-input" title="Permalink to this headline">¶</a></h4>
<p>This error is set when not enough input was given to the decoder to be
able to decode the percent encoded string, e.g. <tt class="docutils literal"><span class="pre">%2</span></tt>.</p>
</div>
<div class="section" id="non-hex-input">
<h4>13.4.2 <tt class="docutils literal"><span class="pre">non_hex_input</span></tt><a class="headerlink" href="#non-hex-input" title="Permalink to this headline">¶</a></h4>
<p>This error is set when non-hex input is given to the decoder,
e.g. <tt class="docutils literal"><span class="pre">%GG</span></tt>.</p>
</div>
<div class="section" id="conversion-failed">
<h4>13.4.3 <tt class="docutils literal"><span class="pre">conversion_failed</span></tt><a class="headerlink" href="#conversion-failed" title="Permalink to this headline">¶</a></h4>
<p>This error is set when the decoder was unable to convert the percent
encoded string, e.g. <tt class="docutils literal"><span class="pre">%80</span></tt>.</p>
</div>
</div>
</div>
<span id="document-class_uri_normalization_level"></span><div class="section" id="enum-class-uri-normalization-level-class-uri-normalization-level">
<span id="uri-normalization-level"></span><h2>14 Enum class <tt class="docutils literal"><span class="pre">uri_normalization_level</span></tt> [class.uri_normalization_level]<a class="headerlink" href="#enum-class-uri-normalization-level-class-uri-normalization-level" title="Permalink to this headline">¶</a></h2>
<div class="highlight-c++"><div class="highlight"><pre><span class="k">enum</span> <span class="k">class</span> <span class="nc">uri_normalization_level</span> <span class="p">{</span>
 <span class="n">string_comparison</span><span class="p">,</span>
 <span class="n">syntax_based</span><span class="p">,</span>
<span class="p">};</span>
</pre></div>
</div>
<div class="section" id="string-comparison">
<h3>14.1 <tt class="docutils literal"><span class="pre">string_comparison</span></tt><a class="headerlink" href="#string-comparison" title="Permalink to this headline">¶</a></h3>
<p>Used to indicate to the <tt class="docutils literal"><span class="pre">normalize</span></tt> or <tt class="docutils literal"><span class="pre">compare</span></tt> member functions
that only the string comparison normalization level in the comparison
ladder must be used when normalizing the <tt class="docutils literal"><span class="pre">uri</span></tt> object.</p>
</div>
<div class="section" id="syntax-based">
<h3>14.2 <tt class="docutils literal"><span class="pre">syntax_based</span></tt><a class="headerlink" href="#syntax-based" title="Permalink to this headline">¶</a></h3>
<p>Used to indicate to the <tt class="docutils literal"><span class="pre">normalize</span></tt> or <tt class="docutils literal"><span class="pre">compare</span></tt> member functions
that only the syntax based normalization level in the comparison
ladder must be used when normalizing the <tt class="docutils literal"><span class="pre">uri</span></tt> object.</p>
</div>
</div>
<span id="document-issues"></span><div class="section" id="issues">
<span id="id1"></span><h2>Issues<a class="headerlink" href="#issues" title="Permalink to this headline">¶</a></h2>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p><strong>Issues</strong></p>
<p><strong>1. Normalization Invariant</strong></p>
<p>During the Chicago meeting, the notion of making normalization an
invariant. The authors of this paper are not yet clear on the
details of this and it needs further discussion before developing
this idea as part of this proposal.</p>
<p><strong>2. Scheme-Specific Normalization</strong></p>
<p>There needs to be an extension point in order to allow scheme- and
protocol- specific normalization.</p>
<p><strong>3. empty() vs. is_absolute() vs. is_opaque()</strong></p>
<p>In the minutes to the Chicago meeting, there was a suggestion that
the <tt class="docutils literal"><span class="pre">is_</span></tt> prefix is being applied inconsistently. The current way
is consistent with at least the filesystem proposal, but
clarification should be made with the LEWG.</p>
<p><strong>4. Factory Functions</strong></p>
<p>The <tt class="docutils literal"><span class="pre">make_uri</span></tt> factory functions are free functions, but the LEWG
needs to clarify if they can remain this way or if they should be
static members of <tt class="docutils literal"><span class="pre">uri</span></tt>.</p>
<p><strong>5. Source Template Parameters</strong></p>
<p class="last">The <tt class="docutils literal"><span class="pre">Source</span></tt> template parameters seem overly generic, this will
be taken up with the LEWG.</p>
</div>
</div>
<span id="document-acknowledgements"></span><div class="section" id="acknowledgements">
<span id="id1"></span><h2>Acknowledgements<a class="headerlink" href="#acknowledgements" title="Permalink to this headline">¶</a></h2>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p>C++ Network Library users and mailing list</p>
<p>Kyle Kloepper and Niklas Gustafsson for providing valuable feedback
and encouragement, and for presenting different versions of this
proposal at committee meetings.</p>
<p>Beman Dawes and his Filesystem proposal from which I was influenced
strongly in the class design.</p>
<p>Thiago Macieira of Qt for important feedback on the draft proposal.</p>
<p class="last">Wikipedia, for being there.</p>
</div>
</div>
</div>
</div>


          </div>
      </div>

      <div class="clearer"></div>
    </div>
    <div class="footer">
    </div>
  </body>
</html>