URIComponents.h

Go to the documentation of this file.

/*  CURIComponents.h - RFC2396 URI handling

    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library 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.
*/

#ifndef OW32_URIComponents_h
#define OW32_URIComponents_h

#include <OW32/OW32Libs.h>
#include <string>

namespace OW32
{

class OW32_LIB_EXPORT CURIComponents
{
public:
    // Flags to say if a component is defined.  Note that each component may
    // be defined but empty, except for the path.
    static const int d_scheme       = 1;
    static const int d_authority    = 2;
    static const int d_query        = 4;
    static const int d_fragment     = 8;

    CURIComponents::CURIComponents() :
        m_defined(0)
    {
    }

    CURIComponents::CURIComponents(
        const char*             uriString,
        std::string::size_type  uriStringLen) : 
        m_defined(0)
    {
        parse(uriString, uriStringLen);
    }

    CURIComponents::CURIComponents(
        const std::string       &uriString) :
        m_defined(0)
    {
        parse(uriString.c_str(), uriString.length());
    }

    void parse(
        const char*             uriString,
        std::string::size_type  uriStringLen);

    void parse(
        const std::string &uriString)
    {
        parse(uriString.c_str(), uriString.length());
    }

    std::string make() const;

    void resolve(const CURIComponents &base);

    void resolve(
        const char                  *base,
        const std::string::size_type baseLen)
    {
        CURIComponents baseURI(base, baseLen);
        return resolve(baseURI);
    }

    void resolve(
        const std::string &base)
    {
        resolve(base.c_str(), base.length());
    }

    static std::string resolve(
        const char              *relative,
        std::string::size_type  relativeLen,
        const char              *base,
        std::string::size_type  baseLen
    );


    static std::string resolve(
        const std::string &relative,
        const std::string &base
    )
    {
        return resolve(relative.c_str(), relative.length(), base.c_str(), base.length());
    }

    void reset() 
    {
        m_defined = 0;
        m_scheme.clear();
        m_authority.clear();
        m_path.clear();
        m_query.clear();
        m_fragment.clear();
    }

    const std::string& getScheme() const 
    { 
        return m_scheme; 
    }

    bool isSchemeDefined() const 
    { 
        return !!(m_defined & d_scheme); 
    }

    void setScheme(const char *scheme) 
    { 
        if (!scheme) {
            m_defined &= ~d_scheme;
            m_scheme.clear();
        } else {
            m_scheme = scheme;
            m_defined |= d_scheme;
        }
    }

    void setScheme(const std::string &scheme) 
    { 
        m_scheme = scheme;
        m_defined |= d_scheme;
    }

    const std::string& getAuthority() const 
    { 
        return m_authority; 
    }

    bool isAuthorityDefined() const 
    { 
        return !!(m_defined & d_authority); 
    }

    void setAuthority(const char *authority) 
    { 
        if (!authority) {
            m_defined &= ~d_authority;
            m_authority.clear();
        } else {
            m_authority = authority;
            m_defined |= d_authority;
        }
    }

    void setAuthority(const std::string &authority) 
    { 
        m_authority = authority;
        m_defined |= d_authority;
    }

    const std::string& getPath() const 
    { 
        return m_path; 
    }

    void setPath(const char *path) 
    { 
        if (!path)
            m_path.clear();
        else
            m_path = path;
    }

    void setPath(const std::string &path) 
    { 
        m_path = path;
    }

    const std::string& getQuery() const 
    { 
        return m_query; 
    }

    bool isQueryDefined() const 
    { 
        return !!(m_defined & d_query); 
    }

    void setQuery(const char *query) 
    { 
        if (!query) {
            m_defined &= ~d_query;
            m_query.clear();
        } else {
            m_query = query;
            m_defined |= d_query;
        }
    }

    void setQuery(const std::string &query) 
    { 
        m_query = query;
        m_defined |= d_query;
    }

    const std::string& getFragment() const 
    { 
        return m_fragment; 
    }

    bool isFragmentDefined() const 
    { 
        return !!(m_defined & d_fragment); 
    }

    void setFragment(const char *fragment) 
    { 
        if (!fragment) {
            m_defined &= ~d_fragment;
            m_fragment.clear();
        } else {
            m_fragment = fragment;
            m_defined |= d_fragment;
        }
    }

    void setFragment(const std::string &fragment) 
    { 
        m_fragment = fragment;
        m_defined |= d_fragment;
    }

    unsigned int getDefined() const
    {
        return m_defined;
    }

    void setDefined(unsigned int defined)
    {
        m_defined = defined;
    }

private:
    std::string     m_scheme;
    std::string     m_authority;
    std::string     m_path;
    std::string     m_query;
    std::string     m_fragment;

    unsigned int    m_defined;
};

class OW32_LIB_EXPORT CServerAuthority
{
public:
    CServerAuthority::CServerAuthority() :
        m_port(-1)
    {
    }

    CServerAuthority::CServerAuthority(
        const char*             authorityString,
        std::string::size_type  authorityStringLen) : 
        m_port(-1)
    {
        parse(authorityString, authorityStringLen);
    }

    CServerAuthority::CServerAuthority(
        const std::string       &authorityString) :
        m_port(-1)
    {
        parse(authorityString.c_str(), authorityString.length());
    }

    void parse(
        const char              *authorityString, 
        std::string::size_type  authorityStringLen);

    std::string make() const;

    void setHost(const std::string &host)
    {
        m_host = host;
    }

    void setHost(const char *host)
    {
        if (!host)
            m_host.clear();
        else
            m_host = host;
    }

    const std::string &getHost() const
    {
        return m_host;
    }
    
    void setPort(const int port)
    {
        m_port = port;
    }

    const int getPort() const
    {
        return m_port;
    }

    void setUser(const char *user)
    {
        if (!user)
            m_user.clear();
        else
            m_user = user;
    }

    void setUser(const std::string &user)
    {
        m_user = user;
    }

    const std::string &getUser() const
    {
        return m_user;
    }

    void setPassword(const std::string &password)
    {
        m_pass = password;
    }
    
    void setPassword(const char *password)
    {
        if (!password)
            m_pass.clear();
        else
            m_pass = password;
    }

    const std::string &getPassword() const
    {
        return m_pass;
    }

private:
    std::string m_host;
    int         m_port;
    std::string m_user;
    std::string m_pass;
};

} // namespace OW32

#endif // OW32_URIComponents_h

---