The URI class parses the given uri using the generic syntax from RFC3986. More...

#include <uri.h>

Collaboration diagram for servus::URI:

Public Types
typedef std::map< std::string, std::string >	KVMap

typedef KVMap::const_iterator	ConstKVIter

Public Member Functions
SERVUS_API	URI ()
	Construct an empty URI. More...

SERVUS_API	URI (const std::string &uri)

SERVUS_API	URI (const char *uri)

SERVUS_API	URI (const URI &from)
	Copy-construct an URI. More...

SERVUS_API URI &	operator= (const URI &rhs)
	Assign the data from another URI. More...

SERVUS_API bool	operator== (const URI &rhs) const
	Equals operator.

SERVUS_API bool	operator!= (const URI &rhs) const
	Not equals operator.

Getters for uri data
SERVUS_API const std::string &	getScheme () const

SERVUS_API const std::string &	getUserinfo () const

SERVUS_API uint16_t	getPort () const

SERVUS_API const std::string &	getHost () const

SERVUS_API const std::string &	getPath () const

SERVUS_API const std::string &	getQuery () const

SERVUS_API const std::string &	getFragment () const

Setters for uri data.
SERVUS_API void	setScheme (const std::string &scheme)

SERVUS_API void	setHost (const std::string &host)

SERVUS_API void	setPort (uint16_t port)

Access to key-value data in query.
SERVUS_API ConstKVIter	queryBegin () const

SERVUS_API ConstKVIter	queryEnd () const

SERVUS_API ConstKVIter	findQuery (const std::string &key) const

SERVUS_API void	addQuery (const std::string &key, const std::string &value)
	Add a key-value pair to the query. More...

Detailed Description

The URI class parses the given uri using the generic syntax from RFC3986.

* http://bob@www.example.com:8080/path/?key=value,foo=bar#fragment
* ^   ^  ^  ^               ^    ^     ^                 ^
* a   b  c  d               e    f     g                 h
*
* URI part  Range   String
* scheme    [a, b)  "http"
* userinfo [c, d) bob
* host  [d, e)  "www.example.com"
* port (e, f) 8080
* path  [f, g)  "/path/"
* query (g, h)  "key=value"
* fragment  (h,-) "fragment"
*

Queries are parsed into key-value pairs and can be accessed using findQuery(), queryBegin() and queryEnd().

Example:

/* Copyright (c) 2013-2014, ahmet.bilgili@epfl.ch
 *                    2015, Juan Hernando <jhernando@fi.upm.es>
 *
 * This file is part of Servus <https://github.com/HBPVIS/Servus>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 3.0 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#define BOOST_TEST_MODULE
#include <boost/test/unit_test.hpp>
#include <servus/uri.h>
BOOST_AUTO_TEST_CASE(test_uri_parts)
{
    const std::string uriStr =
        "http://bob@www.example.com:8080/path/?key=value,foo=bar#fragment";
    BOOST_REQUIRE_NO_THROW( servus::URI uri( uriStr ));
    servus::URI uri( uriStr );
    BOOST_CHECK_EQUAL( uri.getScheme(), "http" );
    BOOST_CHECK_EQUAL( uri.getHost(), "www.example.com" );
    BOOST_CHECK_EQUAL( uri.getUserinfo(), "bob" );
    BOOST_CHECK_EQUAL( uri.getPort(), 8080 );
    BOOST_CHECK_EQUAL( uri.getPath(), "/path/" );
    BOOST_CHECK_EQUAL( uri.getQuery(), "key=value,foo=bar" );
    BOOST_CHECK_EQUAL( uri.getFragment(), "fragment" );
    const servus::URI hostPortURI( "foo://hostname:12345" );
    BOOST_CHECK_EQUAL( hostPortURI.getScheme() ,  "foo" );
    BOOST_CHECK_EQUAL( hostPortURI.getHost() , "hostname" );
    BOOST_CHECK_EQUAL( hostPortURI.getPort(), 12345 );
    const servus::URI uppercaseURI( "FOO:" );
    BOOST_CHECK_EQUAL( hostPortURI.getScheme(), "foo" );
}
BOOST_AUTO_TEST_CASE(test_setters)
{
    servus::URI uri;
    uri.setScheme( "foo" );
    BOOST_CHECK_EQUAL( uri.getScheme(), "foo" );
    uri.setHost( "host" );
    BOOST_CHECK_EQUAL( uri.getHost(), "host" );
    uri.setPort( 12345 );
    BOOST_CHECK_EQUAL( uri.getPort(), 12345 );
}
BOOST_AUTO_TEST_CASE(test_empty_uri)
{
    servus::URI empty;
    BOOST_CHECK( empty.getScheme().empty( ));
    BOOST_CHECK( empty.getHost().empty( ));
    BOOST_CHECK( empty.getUserinfo().empty( ));
    BOOST_CHECK_EQUAL( empty.getPort(), 0 );
    BOOST_CHECK( empty.getPath().empty( ));
    BOOST_CHECK( empty.getQuery().empty( ));
    BOOST_CHECK( empty.getFragment().empty( ));
}
BOOST_AUTO_TEST_CASE(test_file_uris)
{
    servus::URI file1( "/bla.txt" );
    BOOST_CHECK_EQUAL( file1.getPath(), "/bla.txt" );
    BOOST_CHECK( file1.getHost().empty( ));
    BOOST_CHECK( file1.getScheme().empty( ));
    BOOST_CHECK( file1.getQuery().empty( ));
    BOOST_CHECK( file1.getFragment().empty( ));
    servus::URI file2( "bla.txt" );
    BOOST_CHECK_EQUAL( file2.getPath(), "bla.txt" );
    BOOST_CHECK( file2.getHost().empty( ));
    BOOST_CHECK( file2.getScheme().empty( ));
    BOOST_CHECK( file2.getQuery().empty( ));
    BOOST_CHECK( file2.getFragment().empty( ));
    servus::URI file3( "file:///bla.txt" );
    BOOST_CHECK_EQUAL( file3.getPath(), "/bla.txt" );
    BOOST_CHECK( file3.getHost().empty( ));
    BOOST_CHECK_EQUAL( file3.getScheme(), "file" );
    BOOST_CHECK( file3.getQuery().empty( ));
    BOOST_CHECK( file3.getFragment().empty( ));
    servus::URI file4( "file://bla.txt" );
    BOOST_CHECK_EQUAL( file4.getPath(), "bla.txt" );
    BOOST_CHECK( file4.getHost().empty( ));
    BOOST_CHECK_EQUAL( file4.getScheme(), "file" );
    BOOST_CHECK( file4.getQuery().empty( ));
    BOOST_CHECK( file4.getFragment().empty( ));
    servus::URI file5( "scheme://bla.txt" );
    BOOST_CHECK_EQUAL( file5.getHost(), "bla.txt" );
    BOOST_CHECK( file5.getPath().empty( ));
    BOOST_CHECK_EQUAL( file5.getScheme(), "scheme" );
    BOOST_CHECK( file5.getQuery().empty( ));
    BOOST_CHECK( file5.getFragment().empty( ));
    servus::URI path1( "foo:/bla.txt" );
    BOOST_CHECK( path1.getHost().empty( ));
    BOOST_CHECK_EQUAL( path1.getPath(), "/bla.txt" );
    BOOST_CHECK_EQUAL( path1.getScheme(), "foo" );
    BOOST_CHECK( path1.getQuery().empty( ));
    BOOST_CHECK( path1.getFragment().empty( ));
    servus::URI path2( "foo:bla.txt" );
    BOOST_CHECK( path2.getHost().empty( ));
    BOOST_CHECK_EQUAL( path2.getPath(), "bla.txt" );
    BOOST_CHECK_EQUAL( path2.getScheme(), "foo" );
    BOOST_CHECK( path2.getQuery().empty( ));
    BOOST_CHECK( path2.getFragment().empty( ));
}
BOOST_AUTO_TEST_CASE(test_uri_query)
{
    const std::string uriStr =
        "http://bob@www.example.com:8080/path/?key=value,foo=bar#fragment";
    servus::URI uri( uriStr );
    BOOST_CHECK( uri.findQuery( "key" ) != uri.queryEnd( ));
    BOOST_CHECK( uri.findQuery( "foo" ) != uri.queryEnd( ));
    BOOST_CHECK( uri.findQuery( "bar" ) == uri.queryEnd( ));
    BOOST_CHECK_EQUAL( uri.findQuery( "key" )->second, "value" );
    BOOST_CHECK_EQUAL( uri.findQuery( "foo" )->second, "bar" );
    uri.addQuery( "hans", "dampf" );
    BOOST_CHECK_EQUAL( uri.findQuery( "key" )->second, "value" );
    BOOST_CHECK_EQUAL( uri.findQuery( "foo" )->second, "bar" );
    BOOST_CHECK_EQUAL( uri.findQuery( "hans" )->second, "dampf" );
    BOOST_CHECK( uri.getQuery().find( "hans=dampf" ) != std::string::npos );
}
BOOST_AUTO_TEST_CASE(test_uri_comparisons)
{
    const std::string uriStr =
        "http://bob@www.example.com:8080/path/?key=value,foo=bar#fragment";
    servus::URI uri( uriStr );
    BOOST_CHECK( uri == uri );
    BOOST_CHECK( uri == servus::URI( uriStr ));
    BOOST_CHECK( uri != servus::URI(
                           "http://bob@www.example.com:8080/path/?key=value" ));
    BOOST_CHECK( uri != servus::URI(
          "http://bob@www.example.com:8030/path/?key=value,foo=bar#fragment" ));
    BOOST_CHECK( uri != servus::URI(
                  "http://bob@foo.com:8080/path/?key=value,foo=bar#fragment" ));
    std::stringstream sstr;
    sstr << uri;
    BOOST_CHECK_EQUAL( sstr.str(), uriStr );
    sstr.str( "" );
    sstr << servus::URI( "http://www.example.com/path" );
    BOOST_CHECK_EQUAL( sstr.str(), "http://www.example.com/path" );
    sstr.str( "" );
    sstr << servus::URI( "/path" );
    BOOST_CHECK_EQUAL( sstr.str(), "/path" );
}
BOOST_AUTO_TEST_CASE(test_invalid_uri)
{
    BOOST_CHECK_THROW( servus::URI uri( "bad_schema:" ),
                       std::exception );
    BOOST_CHECK_THROW( servus::URI uri( "8ad-schema:" ),
                       std::exception );
    BOOST_CHECK_NO_THROW( servus::URI uri( "g00d-sch+ma:" ));
    BOOST_CHECK_THROW( servus::URI uri( "http://host:port" ),
                       std::exception );
    BOOST_CHECK_THROW( servus::URI uri( "http://host:" ),
                       std::exception );
}
BOOST_AUTO_TEST_CASE(test_corner_cases)
{
    servus::URI uri1( "path/foo:bar" );
    BOOST_CHECK_EQUAL( uri1.getPath(), "path/foo:bar" );
    servus::URI uri2( "//path/foo:bar" );
    BOOST_CHECK_EQUAL( uri2.getPath(), "//path/foo:bar" );
    servus::URI uri3( "?/##" );
    BOOST_CHECK_EQUAL( uri3.getQuery(), "/" );
    BOOST_CHECK_EQUAL( uri3.getFragment(), "#" );
    servus::URI uri4( "#:" );
    BOOST_CHECK_EQUAL( uri4.getFragment(), ":" );
    servus::URI uri5( "/foo#?" );
    BOOST_CHECK_EQUAL( uri5.getPath(), "/foo" );
    BOOST_CHECK_EQUAL( uri5.getFragment(), "?" );
    servus::URI uri6( "foo://*:0" );
    BOOST_CHECK_EQUAL( uri6.getScheme(), "foo" );
    BOOST_CHECK_EQUAL( uri6.getHost(), "*" );
}

Definition at line 54 of file uri.h.

Constructor & Destructor Documentation

SERVUS_API servus::URI::URI ( )

Construct an empty URI.

SERVUS_API servus::URI::URI ( const std::string & uri )

explicit

Parameters

uri	URI string to parse.

Exceptions

std::exception for incomplete URIs, and boost::bad_lexical_cast if the port is not a number.

SERVUS_API servus::URI::URI ( const char * uri )

explicit

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

SERVUS_API servus::URI::URI ( const URI & from )

Copy-construct an URI.

Member Function Documentation

SERVUS_API void servus::URI::addQuery	(	const std::string &	key,
		const std::string &	value
	)

Add a key-value pair to the query.

SERVUS_API ConstKVIter servus::URI::findQuery ( const std::string & key ) const

Returns: a const iterator to the given key, or queryEnd().

SERVUS_API URI& servus::URI::operator= ( const URI & rhs )

Assign the data from another URI.

SERVUS_API ConstKVIter servus::URI::queryBegin ( ) const

Returns: a const iterator to the beginning of the query map.

SERVUS_API ConstKVIter servus::URI::queryEnd ( ) const

Returns: a const iterator to end beginning of the query map.

The documentation for this class was generated from the following file:

uri.h

Public Types

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation