UT_Url.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be rurlroduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_Url.h
 *
 * COMMENTS:
 *
 */

#ifndef __UT_URL_H__
#define __UT_URL_H__

#include "UT_API.h"

#include "UT_StringHolder.h"
#include "UT_StringView.h"
#include "UT_ORMColumnType.h"

#include <iostream>

class UT_SqlStatement;

class UT_API UT_Url
{
public:
    enum Protocol
    {
        PROT_UNKNOWN,
        PROT_HTTP,
        PROT_HTTPS,
        PROT_WS,
        PROT_WSS,
        PROT_SMTP,
        PROT_LDAP,
        PROT_LDAPS
    };

    enum FormattingOptions : unsigned
    {
        None = 0x0,
        RemoveProtocol = 1 << 0,
        RemovePassword = 1 << 1,
        RemoveUserInfo = RemovePassword | 1 << 2,
        RemovePort = 1 << 3,
        RemovePath = 1 << 4,
        RemoveQuery = 1 << 5
    };

    UT_Url();
    explicit UT_Url(const UT_StringRef &url_string,
           Protocol force_protocol = PROT_UNKNOWN);
    UT_Url(Protocol prot,
           const UT_StringHolder &host,
           int port,
           const UT_StringHolder &path);
    UT_Url(Protocol prot,
           const UT_StringHolder &user,
           const UT_StringHolder &password,
           const UT_StringHolder &host,
           int port,
           const UT_StringHolder &path,
           const UT_StringHolder &query_string);

    UT_Url(const UT_Url &url) = default;
    UT_Url &operator=(const UT_Url &url) = default;
    UT_Url(UT_Url &&url) = default;
    UT_Url &operator=(UT_Url &&url) = default;

    UT_Url& operator=(const UT_StringRef& url_str)
    {
        parse(url_str);
        return *this;
    }

    // This clears the entire url and parses the url string passed in.
    // Returns true if the url was successfully parsed.
    bool parse(const UT_StringRef &str_url,
               Protocol force_protocol = PROT_UNKNOWN);

    void clear();

    // The only part of the url that is actually required is the host.
    bool isUsable() const { return !myHost.isEmpty(); }

    explicit operator bool() const { return isUsable(); }
    bool operator==(const UT_Url &url) const;
    bool operator!=(const UT_Url &url) const;

    // Use FormattingOptions to specify which elements of the url you would like
    // to strip. The default is to include all elements when necessary
    UT_StringHolder toString(unsigned format = FormattingOptions::None) const;
    // Helper if only the host and port are wanted.
    UT_StringHolder toHostPort() const
    {
        UT_StringHolder str;
        str.format("{}:{}", myHost, port());
        return str;
    }
    UT_StringHolder protocolToString() const;

    bool usingDefaultPortForProtocol() const;
    static bool isDefaultPortForProtocol(Protocol prot, int port);

    inline bool hasMatchingPath(const UT_Url &url) const;
    inline bool hasMatchingPath(const UT_StringHolder &path) const;

    // This is the relaxed method for checking hosts.
    bool hasMatchingHost(const UT_Url &url) const;
    // This is the relaxed method for checking hosts.
    bool hasMatchingHost(const UT_StringHolder &host) const;

    Protocol protocol() const { return myProtocol; }
    void setProtocol(Protocol protocol) { myProtocol = protocol; }

    const UT_StringHolder &user() const { return myUser; }
    void setUser(const UT_StringHolder &user) { myUser = user; }

    const UT_StringHolder &password() const { return myPassword; }
    void setPassword(const UT_StringHolder &pass) { myPassword = pass; }

    const UT_StringHolder &host() const { return myHost; }
    void setHost(const UT_StringHolder &host) { myHost = host; }

    // Get a port that is usable for network calls.
    int port() const;
    int rawPort() const { return myPort; }
    void setPort(int port) { myPort = port; }

    const UT_StringHolder &path() const { return myPath; }
    void setPath(const UT_StringHolder &path) { myPath = path; }

    const UT_StringHolder &queryString() const { return myQueryString; }
    void setQueryString(const UT_StringHolder &query) { myQueryString = query; }

    // In some cases we want to return a const reference to a url or we
    // want to pass an invalid url to signal not using it.
    static const UT_Url theInvalidUrl;
private:
    Protocol myProtocol;
    UT_StringHolder myCustomProtocol;
    UT_StringHolder myUser;
    UT_StringHolder myPassword;
    UT_StringHolder myHost;
    int myPort;
    UT_StringHolder myPath;
    UT_StringHolder myQueryString;
};

inline bool
UT_Url::operator==(const UT_Url &url) const
{
    return myProtocol == url.myProtocol && myUser == url.myUser &&
           myPassword == url.myPassword && hasMatchingHost(url) &&
           port() == url.port() && hasMatchingPath(url) &&
           myQueryString == url.myQueryString;
}

inline bool
UT_Url::operator!=(const UT_Url &url) const
{
    return !(*this == url);
}

inline bool
UT_Url::hasMatchingPath(const UT_Url &url) const
{
    return hasMatchingPath(url.path());
}

inline bool
UT_Url::hasMatchingPath(const UT_StringHolder &path) const
{
    UT_StringView path_view(myPath.begin(), myPath.end());
    UT_StringView other_path_view(path.begin(), path.end());

    // Trim off trailing and leading '/'
    path_view = path_view.trim("/");
    other_path_view = other_path_view.trim("/");

    return path_view == other_path_view;
}

UT_API bool UTsqlBind(UT_SqlStatement& stmt, int idx, const UT_Url& url);
UT_API bool UTsqlGet(const UT_SqlStatement& stmt, int idx , UT_Url& url);

template <>
inline UT_ORMColumnType
UTsqlOrmColumnType<UT_Url>()
{
    return UT_ORMColumnType::String;
}

#endif // __UT_URL_H__