[Home]	[About]
[Screenshots]	[Download]
[News]	[Community]
[Documentation]	[Manual]
[Bugs & Requests]	[Wiki]

/home/tetron/hack/vos/libs/vos/vutil/url.hh

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001-2004 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    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., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <http://www.interreality.org>
*/
#ifndef _VUTIL_URL_HH_
#define _VUTIL_URL_HH_

/** @file
    Defines URL class.
*/

#include <string>
#include <stdexcept>

#include <boost/thread/mutex.hpp>

#include <vos/vutil/vutildefs.hh>

namespace VUtil
{
    /** @class BadURLError url.hh vos/vos/url.hh
        @ingroup libvutil
    */
    class VUTIL_API BadURLError : public std::runtime_error {
    public:
        BadURLError(const std::string& s) : runtime_error(s) { }
    };

    /** @class URL url.hh vos/vos/url.hh
        @ingroup libvos
        A class implementing basic handling of Uniform Resource Locator
        (URL) expressions.
     */
    class VUTIL_API URL
    {
    private:
        mutable boost::mutex url_mutex;

        std::string protocol;
        std::string host;
        std::string port;
        std::string path;
        std::string hostandport;
        std::string allbutpath;

        std::string urlstr;

        static URL& defaults();
        void makeURLstr();

        void parse(const std::string& s);
    public:

        /** Construct a URL using the default fields.
         */
        URL();

        /** Construct a URL using the supplied fields
            @param protocol the protocol field
            @param host the host field
            @param port the port field
            @param path everything after the port
         */
        URL(const std::string& protocol,
            const std::string& host,
            const std::string& port,
            const std::string& path);

        /** Construct a URL by parsing the supplied URL std::string.
            Empty fields will be filled
            in using the default if they are not found!
            @param url a URL in the usual form ("protocol://host:port/path")
            @throws BadURLError if
        */
        URL(const std::string& url);

        URL(const URL& url);

        URL& operator=(const URL& u);
        URL& operator=(const std::string& s);

        /** Get a std::string representation of the URL in the usual form
            ("protocol://host:port/path")
            @return the URL std::string
         */
        std::string getString() const;

        /** Set a URL object used to supply default fields used by the constructors.
            @param url an already-initialized URL object
        */
        static void setDefaults(URL& url);

        /** @return the protocol field */
        std::string getProtocol() const;

        /** @return the host field */
        std::string getHost() const;

        /** @return the port field */
        std::string getPort() const;

        /** @return the path field */
        std::string getPath() const;

        /** @return the host and port in the form "host:port" */
        std::string getHostAndPort() const;

        /** @return everything but the path in the form "proto://host:port" */
        std::string getAllButPath() const;

        /** @param p set the protocol field */
        void setProtocol(const std::string& p);

        /** @param h set the host field */
        void setHost(const std::string& h);

        /** @param p set the port field */
        void setPort(const std::string& p);

        /** @param p set the port field */
        void setPort(unsigned int p);

        /** @param p set the path field */
        void setPath(const std::string& p);

        /** @param hp set the host and port fields together, supplied in
            the form "host:port" */
        void setHostAndPort(const std::string& hp);
    };
}

#endif