cpp-netlib v0.9.3

Home | Table of contents | What's new | Getting started | Examples | In depth | Reference

« previous | up | next »

The URI class

In addition to protocol implementations, the cpp-netlib provides a powerful URI class. The class implements a parser based on RFC 3986 and RFC 2732.

Generic URI syntax overview

A generic URI will take the form:

[scheme:]scheme-specific-part[#fragment]

A URI is known as absolute if it specifies the scheme. Otherwise, it is known as a relative URI. Currently, uri supports only absolute URIs.

URIs can be further classified according to whether they’re hierarchical or opaque (non-hierarchical).

Some examples of non-hierarchical URIs include:

mailto:john.doe@example.com
news:comp.infosystems.www.servers.unix
tel:+1-816-555-1212

The data following the first ":" is said to be opaque to the URI parser and requires no further parsing. By way of example, the following shows how a non-hierarchical URI is processed by the parser by defining everything after the ":" to be a part of the path:

A hierarchical URI is identified by a double slash ("//") after the scheme and a scheme-specific component, which RFC 3986 defines to be:

[scheme:][//authority][path][?query][#fragment]

The authority component can be further broken down to:

[user_info@]host[:port]

Examples of hierarchical URIs include:

http://www.boost.org/
file:///bin/bash

The following example, describing a complex URI using FTP, shows how a URI is broken down by the parser:

Note that the authority is further subdivided into different elements. Another example, using HTTP is given below:

The difference here between the path in a hierarchical URI and that in the example above for the non-hierarchical URI.

The uri class

As of version 0.9.3, uri supplies a URI parser and builder. To use the parser, it’s as simple as supplying a string to the constructor:

using namespace boost::network;
uri::uri instance("http://cpp-netlib.github.com/");
assert(instance.is_valid());
std::cout << "scheme: " << instance.scheme() << std::endl
          << "host: " << instance.host() << std::endl;

The command-line output of this program will be:

scheme: http
host: cpp-netlib.github.com

The uri builder

uri support a stream style syntax to create a URI from it’s elements. For example the program:

#include <iostream>
#include <boost/network/uri.hpp>
#include <boost/network/uri/uri_io.hpp>
using namespace boost::network;

int main() {
    uri::uri url;
    url << uri::scheme("http")
        << uri::host("www.github.com")
        << uri::path("/cpp-netlib");
    std::cout << url << std::endl;
    return 0;
}

will output:

htp://www.github.com/cpp-netlib

URI Concept

Legend

U:The URI type. u,u_:An instance of M. S:A string type. s,v:An instance of S. T:The Tag type.

Construct	Result	Description
U(u)	Instance of U	Copy constructible.
U(s)	Instance of U	Constructible from string.
u = u_;	Reference to u	Assignable.
u = s;	Reference to u	Assignable from string.
swap(u, u_);	void	Swappable.
scheme(u);	Convertible to S	Retrieve the URI scheme of u.
user_info(u);	Convertible to S	Retrieve the user info of u.
host(u);	Convertible to S	Retrieve the host of u.
port(u);	Convertible to H	Retrieve the port of u.
path(u);	Convertible to S	Retrieve the path of u.
query(u);	Convertible to S	Retrieve the query string of u.
fragment(u);	Convertible to S	Retrieve the fragment of u.

« previous | up | next »